package com.wicket.okrapp.biz.service.impl;

import com.wicket.okrapp.biz.service.dto.req.*;
import com.wicket.okrapp.biz.service.dto.res.*;
import com.wicket.okrapp.common.exception.BizException;
import com.wicket.okrapp.common.util.CommonFunctionHelper;
import com.wicket.okrapp.common.util.RedisUtil;

import java.util.stream.Collectors;
import javax.annotation.Resource;

import com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerDetailComReqDto;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.wicket.okrframework.integration.dto.ImplementDeviceAcquisitionOrgPersonalInfoComRespDto;
import com.wicket.okrframework.integration.dto.ImplementDeviceAcquisitionOrgPersonalInfoComReqDto;
import com.wicket.okrcomponent.integration.dto.QueryConfItemDetailComRespDto;
import com.wicket.okrcomponent.integration.dto.QueryConfItemDetailComReqDto;
import com.wicket.okrcomponent.integration.dto.ImplementRoboticSceneSemanticEngineComRespDto;
import com.wicket.okrcomponent.integration.dto.ImplementRoboticSceneSemanticEngineComReqDto;
import com.wicket.okrcomponent.integration.dto.ImplementMutDataToOneDatasComRespDto;
import com.wicket.okrcomponent.integration.dto.ImplementMutDataToOneDatasComReqDto;
import com.wicket.okrcomponent.integration.dto.ImplementGuidedThirdPartyIntelligentQaComRespDto;
import com.wicket.okrcomponent.integration.dto.ImplementGuidedThirdPartyIntelligentQaComReqDto;
import com.wicket.okrcomponent.integration.dto.GetListIntelligentAnswersDto;
import com.wicket.okrcomponent.integration.dto.ImplementManuallyParsingInstructionParametersComRespDto;
import com.wicket.okrcomponent.integration.dto.ImplementManuallyParsingInstructionParametersComReqDto;
import com.wicket.okrcomponent.integration.dto.ImplementStrongReminderListComRespDto;
import com.wicket.okrcomponent.integration.dto.ImplementStrongReminderListComReqDto;
import com.wicket.okrcomponent.integration.dto.ImplementDataAppointFormatShiftTextComRespDto;
import com.wicket.okrcomponent.integration.dto.ImplementDataAppointFormatShiftTextComReqDto;
import com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerDetailComRespDto;
import com.wicket.okrframework.integration.dto.QueryInductionDeptDetailComRespDto;
import com.wicket.okrframework.integration.dto.QueryInductionDeptDetailComReqDto;
import com.wicket.okrframework.integration.dto.QueryUserInfoDetailComRespDto;
import com.wicket.okrframework.integration.dto.QueryUserInfoDetailComReqDto;
import cn.hutool.core.collection.CollectionUtil;
import com.wicket.okrapp.common.exception.Assert;
import com.wicket.okrapp.biz.service.nb.NbIntelligentCommunication;
import com.wicket.okrframework.integration.FwBaseOrgClient;
import com.wicket.okrcomponent.integration.FwCompConfSchemeClient;
import com.wicket.okrcomponent.integration.FwCompTemplateEngineClient;
import com.wicket.okrcomponent.integration.FwCompInterfaceModeClient;
import com.wicket.okrcomponent.integration.FwCompIntelligentCommunicationClient;
import com.wicket.okrframework.integration.FwBaseInductionRecordClient;
import com.wicket.okrframework.integration.FwBaseUserClient;
import com.wicket.okrapp.biz.service.QuestionService;
import com.wicket.okrapp.biz.service.WorkTasksService;
import com.wicket.okrapp.base.service.MOmsEvaBatchRelatedSetService;
//import com.wicket.okrapp.integration.dto.QueryConfItemMatchAnswerDetailComReqDto;
import com.wicket.okrframework.integration.dto.QueryAppDetailComRespDto;
import com.wicket.okrframework.integration.dto.QueryAppDetailComReqDto;
import com.wicket.okrframework.integration.dto.QueryMemberProfileDetailComRespDto;
import com.wicket.okrframework.integration.dto.QueryMemberProfileDetailComReqDto;
import com.wicket.okrcomponent.integration.dto.QueryChannelDetailComRespDto;
import com.wicket.okrcomponent.integration.dto.QueryChannelDetailComReqDto;
import com.wicket.okrcomponent.integration.dto.ImplementInitializationMemberChannelComRespDto;
import com.wicket.okrcomponent.integration.dto.ImplementInitializationMemberChannelComReqDto;
import com.wicket.okrcomponent.integration.dto.ImplementGroupSendMessagesNpeopleComRespDto;
import com.wicket.okrcomponent.integration.dto.ImplementGroupSendMessagesNpeopleComReqDto;
import com.wicket.okrcomponent.integration.dto.QueryPushThirdPartyMessagesListComRespDto;
import com.wicket.okrcomponent.integration.dto.QueryPushThirdPartyMessagesListComReqDto;
import com.wicket.okrcomponent.integration.dto.QueryMemberChannelDetailComRespDto;
import com.wicket.okrcomponent.integration.dto.QueryMemberChannelDetailComReqDto;
import com.wicket.okrframework.integration.FwBaseBaseClient;
import com.wicket.okrframework.integration.FwBaseMemberClient;
import com.wicket.okrcomponent.integration.FwCompMessageClient;
import com.wicket.okrcomponent.integration.dto.QueryMeMessageVirtualImageDetailComRespDto;
import com.wicket.okrcomponent.integration.dto.QueryMeMessageVirtualImageDetailComReqDto;
//import com.wicket.okrapp.integration.dto.QueryConfItemMatchAnswerDetailComReqDto;
import com.wicket.okrcomponent.integration.dto.ImplementDateFormatComRespDto;
import com.wicket.okrcomponent.integration.dto.ImplementDateFormatComReqDto;
import com.wicket.okrapp.biz.service.MessageService;
import com.wicket.okrcomponent.integration.dto.ImplementMarkdownTurnToTextComRespDto;
import com.wicket.okrcomponent.integration.dto.ImplementMarkdownTurnToTextComReqDto;
import com.wicket.okrcomponent.integration.dto.GenerateSemanticInstanceStoryComRespDto;
import com.wicket.okrcomponent.integration.dto.GenerateSemanticInstanceStoryComReqDto;
import com.wicket.okrcomponent.integration.dto.ImplementMulitDataToOneDatasComRespDto;
import com.wicket.okrcomponent.integration.dto.ImplementMulitDataToOneDatasComReqDto;
import com.wicket.okrcomponent.integration.dto.ImplementPullNPeopleBuildGroupComRespDto;
import com.wicket.okrcomponent.integration.dto.ImplementPullNPeopleBuildGroupComReqDto;
import com.wicket.okrcomponent.integration.dto.ImplementNewInitializationMessageNumComRespDto;
import com.wicket.okrcomponent.integration.dto.ImplementNewInitializationMessageNumComReqDto;
import com.wicket.okrcomponent.integration.dto.ImplementDetermineTypeIdeaComRespDto;
import com.wicket.okrcomponent.integration.dto.ImplementDetermineTypeIdeaComReqDto;
//import com.wicket.okrapp.integration.dto.QueryConfItemMatchAnswerDetailComReqDto;

/**
 * @author ：
 * @date ：
 *
 *
 * @version 1.0
 */
@Service
public class IntelligentCommunicationServiceImpl
  implements com.wicket.okrapp.biz.service.IntelligentCommunicationService {

  @Resource
  private RedisUtil redisUtil;
//@Resource
 //private MMmmShellService mMmmShellService;
@Resource
  private NbIntelligentCommunication nbIntelligentCommunication;
@Resource
  private FwBaseOrgClient fwBaseOrgClient;
@Resource
  private FwCompConfSchemeClient fwCompConfSchemeClient;
@Resource
  private FwCompTemplateEngineClient fwCompTemplateEngineClient;
@Resource
  private FwCompInterfaceModeClient fwCompInterfaceModeClient;
@Resource
  private FwCompIntelligentCommunicationClient fwCompIntelligentCommunicationClient;
@Resource
  private FwBaseInductionRecordClient fwBaseInductionRecordClient;
@Resource
  private FwBaseUserClient fwBaseUserClient;
@Resource
  private QuestionService questionService;
@Resource
  private WorkTasksService workTasksService;
@Resource
  private MOmsEvaBatchRelatedSetService mOmsEvaBatchRelatedSetService;
@Resource
  private FwBaseBaseClient fwBaseBaseClient;
@Resource
  private FwBaseMemberClient fwBaseMemberClient;
@Resource
  private FwCompMessageClient fwCompMessageClient;
//@Resource
 //private MCustomFields4Service mCustomFields4Service;
@Resource
  private MessageService messageService;
//@Resource
 //private MSpecMethordTableService mSpecMethordTableService;
/**
   * D3执行智能指令沟通服务(公共)[8102]
   * gen by moon at 12/13/2024, 11:13:11 PM
   */
  @Trace(operationName = "D3执行智能指令沟通服务(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementIntelligentCommandCommunicationServicesComRespDto implementIntelligentCommandCommunicationServicesCom(ImplementIntelligentCommandCommunicationServicesComReqDto reqDto){
    
      
      ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_3 =null;
//virtualUsage M3-约定新增问题任务成功文案  56439
      //ModelCode: receptionService
        ImplementAcceptFieldByStandardDataRespDto receptionServiceRes = null;
    ImplementAcceptFieldByStandardDataReqDto receptionServiceReq=new ImplementAcceptFieldByStandardDataReqDto();
  receptionServiceReq.setCustomField1("您提出的问题已成功～");//CUSTOM_CONVENTION//sourceId:1404693_1_56439
receptionServiceReq.setCustomField2("您安排的任务已成功～");//CUSTOM_CONVENTION//sourceId:1404694_1_56439
receptionServiceReq.setCustomField3("您的想法记录成功，创新的人最有魅力！");//CUSTOM_CONVENTION//sourceId:1479342_1_56439
receptionServiceReq.setCustomField4("您的笔记记录成功，细心的人最有魅力！");//CUSTOM_CONVENTION//sourceId:1495358_1_56439

    /*M3-约定新增问题任务成功文案[7478]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getCustomField1(),"D3执行智能指令沟通服务(公共)-M3-约定新增问题任务成功文案-自定义字段1不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField2(),"D3执行智能指令沟通服务(公共)-M3-约定新增问题任务成功文案-自定义字段2不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField3(),"D3执行智能指令沟通服务(公共)-M3-约定新增问题任务成功文案-自定义字段3不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField4(),"D3执行智能指令沟通服务(公共)-M3-约定新增问题任务成功文案-自定义字段4不能为空",false);
      receptionServiceRes = nbIntelligentCommunication.implementAcceptFieldByStandardData(receptionServiceReq);
      
      
      
//virtualUsage D1执行设备获取组织个人信息(公共)  56344
      ImplementDeviceAcquisitionOrgPersonalInfoComRespDto implementDeviceAcquisitionOrgPersonalInfoComRespDto = null;
    ImplementDeviceAcquisitionOrgPersonalInfoComReqDto implementDeviceAcquisitionOrgPersonalInfoComReqDto=new ImplementDeviceAcquisitionOrgPersonalInfoComReqDto();
  if(reqDto!=null){
      implementDeviceAcquisitionOrgPersonalInfoComReqDto.setSn(reqDto.getSn());//SimpleFieldAssign//sourceId:1401762_1_56344
implementDeviceAcquisitionOrgPersonalInfoComReqDto.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:1401763_1_56344
implementDeviceAcquisitionOrgPersonalInfoComReqDto.setApiKey(reqDto.getApiKey());//SimpleFieldAssign//sourceId:1401764_1_56344
implementDeviceAcquisitionOrgPersonalInfoComReqDto.setApiSecret(reqDto.getApiSecret());//SimpleFieldAssign//sourceId:1401765_1_56344
    }
  
    /*D1执行设备获取组织个人信息(公共)[8108]   */
Assert.isNull(implementDeviceAcquisitionOrgPersonalInfoComReqDto.getAppId(),"D3执行智能指令沟通服务(公共)-D1执行设备获取组织个人信息(公共)-应用ID不能为空",false);
Assert.isNull(implementDeviceAcquisitionOrgPersonalInfoComReqDto.getApiKey(),"D3执行智能指令沟通服务(公共)-D1执行设备获取组织个人信息(公共)-应用key不能为空",false);
Assert.isNull(implementDeviceAcquisitionOrgPersonalInfoComReqDto.getApiSecret(),"D3执行智能指令沟通服务(公共)-D1执行设备获取组织个人信息(公共)-应用密码不能为空",false);
      implementDeviceAcquisitionOrgPersonalInfoComRespDto = fwBaseOrgClient.implementDeviceAcquisitionOrgPersonalInfoCom(implementDeviceAcquisitionOrgPersonalInfoComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
//virtualUsage D1查询就职的部门详情(公共)  56426
      QueryInductionDeptDetailComRespDto queryInductionDeptDetailComRespDto = null;
    if(implementDeviceAcquisitionOrgPersonalInfoComRespDto !=null){
          QueryInductionDeptDetailComReqDto queryInductionDeptDetailComReqDto=new QueryInductionDeptDetailComReqDto();
  queryInductionDeptDetailComReqDto.setInductionUnitTypeCode("DEPT");//sourceId:1403614_1_56426
queryInductionDeptDetailComReqDto.setIsMainInduction("TRUE");//sourceId:1402946_1_56426
queryInductionDeptDetailComReqDto.setIsTransaction("FALSE");//sourceId:1402947_1_56426
queryInductionDeptDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1402948_1_56426
if(implementDeviceAcquisitionOrgPersonalInfoComRespDto!=null){
      queryInductionDeptDetailComReqDto.setUserId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getUserId());//SimpleFieldAssign//sourceId:1403654_1_56426
queryInductionDeptDetailComReqDto.setSpaceId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1402929_1_56426
    }

    /*D1查询就职的部门详情(公共)[7829]   */
    Assert.isNull(queryInductionDeptDetailComReqDto.getUserId(),"D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-个人账号ID不能为空",false);
Assert.isNull(queryInductionDeptDetailComReqDto.getInductionUnitTypeCode(),"D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-就职单位类型实例不能为空",false);
Assert.isNull(queryInductionDeptDetailComReqDto.getIsMainInduction(),"D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-是否主岗不能为空",false);
Assert.isNull(queryInductionDeptDetailComReqDto.getIsTransaction(),"D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-是否异动不能为空",false);
Assert.isNull(queryInductionDeptDetailComReqDto.getSubjectLifeCycle(),"D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-主体生命周期不能为空",false);
Assert.isNull(queryInductionDeptDetailComReqDto.getSpaceId(),"D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-创建于空间ID不能为空",false);
      queryInductionDeptDetailComRespDto = fwBaseInductionRecordClient.queryInductionDeptDetailCom(queryInductionDeptDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//virtualUsage M3推内存  56427
      //ModelCode: publicFieldCache
        ImplementBizPublicFieldPushMemoryRespDto publicFieldCacheRes = null;
    if(queryInductionDeptDetailComRespDto !=null&&implementDeviceAcquisitionOrgPersonalInfoComRespDto !=null){
          ImplementBizPublicFieldPushMemoryReqDto publicFieldCacheReq=new ImplementBizPublicFieldPushMemoryReqDto();
  if(queryInductionDeptDetailComRespDto!=null){
      publicFieldCacheReq.setCreateInductionId(queryInductionDeptDetailComRespDto.getInductionRecordId());//SimpleFieldAssign//sourceId:1403997_1_56427
    }
if(implementDeviceAcquisitionOrgPersonalInfoComRespDto!=null){
      publicFieldCacheReq.setSpaceId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1403998_1_56427
publicFieldCacheReq.setAppId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getAppId());//SimpleFieldAssign//sourceId:1403999_1_56427
    }

    /*M3推内存[4520]  用于定时任务执行时，获取定时任务执行所需的公共信息，存入缓存，供定时任务中虚拟用况使用 */

      publicFieldCacheRes = nbIntelligentCommunication.implementBizPublicFieldPushMemory(publicFieldCacheReq);



           }
//virtualUsage D2查询用于智能问答的指令模板  56345
      QueryConfItemDetailComRespDto queryConfItemDetailComRespDto = null;
    QueryConfItemDetailComReqDto queryConfItemDetailComReqDto=new QueryConfItemDetailComReqDto();
  queryConfItemDetailComReqDto.setConfItemCode("THIRD_QA_SYSTEM");//CUSTOM_CONVENTION//sourceId:1396844_1_56345
queryConfItemDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1396845_1_56345
  
    /*D2查询用于智能问答的指令模板[8110]   */
    Assert.isNull(queryConfItemDetailComReqDto.getConfItemCode(),"D3执行智能指令沟通服务(公共)-D2查询用于智能问答的指令模板-配置项标识不能为空",false);
Assert.isNull(queryConfItemDetailComReqDto.getSubjectLifeCycle(),"D3执行智能指令沟通服务(公共)-D2查询用于智能问答的指令模板-主体生命周期不能为空",false);
      queryConfItemDetailComRespDto = fwCompConfSchemeClient.queryConfItemDetailCom(queryConfItemDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      Assert.isTrue(queryConfItemDetailComRespDto== null||  queryConfItemDetailComRespDto.getConfItemDes() ==null,"找不到数据，系统异常",false);
      
      
//virtualUsage D2执行组装指令模板提问内容  56346
      ImplementRoboticSceneSemanticEngineComRespDto implementRoboticSceneSemanticEngineComRespDto = null;
    if(queryConfItemDetailComRespDto !=null){
          ImplementRoboticSceneSemanticEngineComReqDto implementRoboticSceneSemanticEngineComReqDto=new ImplementRoboticSceneSemanticEngineComReqDto();
  implementRoboticSceneSemanticEngineComReqDto.setTemplateSemanticEngineCode("ASSEMBLY_INSTRUCTION_QUS_CONT_TEMP");//CUSTOM_CONVENTION//sourceId:1401770_1_56346
if(reqDto!=null){
      implementRoboticSceneSemanticEngineComReqDto.setContent(reqDto.getContent());//SimpleFieldAssign//sourceId:1401771_1_56346
    }
if(queryConfItemDetailComRespDto!=null){
      implementRoboticSceneSemanticEngineComReqDto.setInstructionTemplate(queryConfItemDetailComRespDto.getConfItemDes());//SimpleFieldAssign//sourceId:1401772_1_56346
    }
  
    /*D2执行组装指令模板提问内容[8112]   */
    Assert.isNull(implementRoboticSceneSemanticEngineComReqDto.getTemplateSemanticEngineCode(),"D3执行智能指令沟通服务(公共)-D2执行组装指令模板提问内容-模板引擎标识不能为空",false);
Assert.isNull(implementRoboticSceneSemanticEngineComReqDto.getContent(),"D3执行智能指令沟通服务(公共)-D2执行组装指令模板提问内容-消息内容不能为空",false);
Assert.isNull(implementRoboticSceneSemanticEngineComReqDto.getInstructionTemplate(),"D3执行智能指令沟通服务(公共)-D2执行组装指令模板提问内容-指令模板部分内容不能为空",false);
      implementRoboticSceneSemanticEngineComRespDto = fwCompTemplateEngineClient.implementRoboticSceneSemanticEngineCom(implementRoboticSceneSemanticEngineComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      Assert.isTrue(implementRoboticSceneSemanticEngineComRespDto== null||  implementRoboticSceneSemanticEngineComRespDto.getObjectName() ==null,"找不到数据，系统异常",false);
      
      
           }
//virtualUsage D2执行输入消息内容单字段转数据集  56358
      ImplementMutDataToOneDatasComRespDto implementMutDataToOneDatasComRespDto = null;
    if(implementRoboticSceneSemanticEngineComRespDto !=null){
          ImplementMutDataToOneDatasComReqDto implementMutDataToOneDatasComReqDto=new ImplementMutDataToOneDatasComReqDto();
  if(implementRoboticSceneSemanticEngineComRespDto!=null){
      implementMutDataToOneDatasComReqDto.setCustomField(implementRoboticSceneSemanticEngineComRespDto.getObjectName());//SimpleFieldAssign//sourceId:1400663_1_56358
    }
  
    /*D2执行输入消息内容单字段转数据集[5864]   */
    Assert.isNull(implementMutDataToOneDatasComReqDto.getCustomField(),"D3执行智能指令沟通服务(公共)-D2执行输入消息内容单字段转数据集-自定义字段不能为空",false);
      implementMutDataToOneDatasComRespDto = fwCompInterfaceModeClient.implementMutDataToOneDatasCom(implementMutDataToOneDatasComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
           }
//virtualUsage D2执行导向第三方智能问答(公共)  56357
      ImplementGuidedThirdPartyIntelligentQaComRespDto implementGuidedThirdPartyIntelligentQaComRespDto = null;
    if(implementDeviceAcquisitionOrgPersonalInfoComRespDto !=null&&implementMutDataToOneDatasComRespDto !=null){
          ImplementGuidedThirdPartyIntelligentQaComReqDto implementGuidedThirdPartyIntelligentQaComReqDto=new ImplementGuidedThirdPartyIntelligentQaComReqDto();
  implementGuidedThirdPartyIntelligentQaComReqDto.setBusModelVersion("PLUS_VERSION");//sourceId:2036980_1_56357
  if(implementDeviceAcquisitionOrgPersonalInfoComRespDto!=null){
      implementGuidedThirdPartyIntelligentQaComReqDto.setResultAspObjId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1400587_1_56357
    }
if(implementMutDataToOneDatasComRespDto!=null){
      //simpleList-to-objLists
    for (String item : implementMutDataToOneDatasComRespDto.getComDatasList()) {
                GetListIntelligentAnswersDto oneItem = new GetListIntelligentAnswersDto();
                oneItem.setRole("user");//sourceId:282040_2_56357
if(implementMutDataToOneDatasComRespDto!=null){
      oneItem.setContent(item);//SimpleFieldAssign//sourceId:282039_2_56357
    }
               
                implementGuidedThirdPartyIntelligentQaComReqDto.getGetListIntelligentAnswersList().add(oneItem);
            }//sourceId:1400588_1_56357
    }
  
    /*D2执行导向第三方智能问答(公共)[8103]   */
    Assert.isNull(implementGuidedThirdPartyIntelligentQaComReqDto.getResultAspObjId(),"D3执行智能指令沟通服务(公共)-D2执行导向第三方智能问答(公共)-开通对象ID不能为空",false);
Assert.isNull(implementGuidedThirdPartyIntelligentQaComReqDto.getBusModelVersion(),"D3执行智能指令沟通服务(公共)-D2执行导向第三方智能问答(公共)-业务模型版本不能为空",false);
      implementGuidedThirdPartyIntelligentQaComRespDto = fwCompIntelligentCommunicationClient.implementGuidedThirdPartyIntelligentQaCom(implementGuidedThirdPartyIntelligentQaComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      Assert.isTrue(implementGuidedThirdPartyIntelligentQaComRespDto== null||  implementGuidedThirdPartyIntelligentQaComRespDto.getContent() ==null||implementGuidedThirdPartyIntelligentQaComRespDto== null||  implementGuidedThirdPartyIntelligentQaComRespDto.getRole() ==null,"找不到数据，系统异常",false);
      
      
           }
//virtualUsage D2执行人工解析指令参数(公共)  56347
      ImplementManuallyParsingInstructionParametersComRespDto implementManuallyParsingInstructionParametersComRespDto = null;
    if(implementGuidedThirdPartyIntelligentQaComRespDto !=null){
          ImplementManuallyParsingInstructionParametersComReqDto implementManuallyParsingInstructionParametersComReqDto=new ImplementManuallyParsingInstructionParametersComReqDto();
  if(implementGuidedThirdPartyIntelligentQaComRespDto!=null){
      implementManuallyParsingInstructionParametersComReqDto.setContent(implementGuidedThirdPartyIntelligentQaComRespDto.getContent());//SimpleFieldAssign//sourceId:1400664_1_56347
    }
  
    /*D2执行人工解析指令参数(公共)[8104]   */
    Assert.isNull(implementManuallyParsingInstructionParametersComReqDto.getContent(),"D3执行智能指令沟通服务(公共)-D2执行人工解析指令参数(公共)-消息内容不能为空",false);
      implementManuallyParsingInstructionParametersComRespDto = fwCompIntelligentCommunicationClient.implementManuallyParsingInstructionParametersCom(implementManuallyParsingInstructionParametersComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
           }
if((implementManuallyParsingInstructionParametersComRespDto!= null&&  implementManuallyParsingInstructionParametersComRespDto.getCustomField() !=null && implementManuallyParsingInstructionParametersComRespDto.getCustomField().equals("IMPORT_WORK_REMIND"))) {
        //if(D2执行人工解析指令参数(公共).自定义字段 等于 了解重要工作提醒)  56348
        
ImplementStrongReminderListComRespDto implementStrongReminderListComRespDto = null;
    if(implementDeviceAcquisitionOrgPersonalInfoComRespDto !=null){
          ImplementStrongReminderListComReqDto implementStrongReminderListComReqDto=new ImplementStrongReminderListComReqDto();
  implementStrongReminderListComReqDto.setMessageImportantLevel(Long.valueOf(3));//CUSTOM_CONVENTION//sourceId:1400701_1_56359
implementStrongReminderListComReqDto.setIsRead("FALSE");//sourceId:1400702_1_56359
if(implementDeviceAcquisitionOrgPersonalInfoComRespDto!=null){
      implementStrongReminderListComReqDto.setOriginalRoleMemberId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1400699_1_56359
implementStrongReminderListComReqDto.setUserId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getUserId());//SimpleFieldAssign//sourceId:1400700_1_56359
implementStrongReminderListComReqDto.setSpaceId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1400703_1_56359
    }
  
    /*D2执行强提醒列表(公共)[8106]   */
    Assert.isNull(implementStrongReminderListComReqDto.getOriginalRoleMemberId(),"D3执行智能指令沟通服务(公共)-D2执行强提醒列表(公共)-所属身份人员ID不能为空",false);
Assert.isNull(implementStrongReminderListComReqDto.getUserId(),"D3执行智能指令沟通服务(公共)-D2执行强提醒列表(公共)-所属个人账号ID不能为空",false);
Assert.isNull(implementStrongReminderListComReqDto.getMessageImportantLevel(),"D3执行智能指令沟通服务(公共)-D2执行强提醒列表(公共)-消息重要紧急度层级不能为空",false);
Assert.isNull(implementStrongReminderListComReqDto.getIsRead(),"D3执行智能指令沟通服务(公共)-D2执行强提醒列表(公共)-是否已读不能为空",false);
Assert.isNull(implementStrongReminderListComReqDto.getSpaceId(),"D3执行智能指令沟通服务(公共)-D2执行强提醒列表(公共)-创建于空间ID不能为空",false);
      implementStrongReminderListComRespDto = fwCompIntelligentCommunicationClient.implementStrongReminderListCom(implementStrongReminderListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
           }
if((implementStrongReminderListComRespDto!= null&&  implementStrongReminderListComRespDto.getMessageList() !=null && implementStrongReminderListComRespDto.getMessageList().size()==0)) {
        //if(D2执行强提醒列表(公共).消息列表数据集条数 等于 0)  59113

//异常结束 59116
      throw new BizException("C00276","您没有最新提醒，请与我说其他内容～",false);
           }
ImplementDataAppointFormatShiftTextComRespDto implementDataAppointFormatShiftTextComRespDto = null;
    if(implementStrongReminderListComRespDto !=null){
          ImplementDataAppointFormatShiftTextComReqDto implementDataAppointFormatShiftTextComReqDto=new ImplementDataAppointFormatShiftTextComReqDto();
  implementDataAppointFormatShiftTextComReqDto.setCustomField1("#");//CUSTOM_CONVENTION//sourceId:1412758_1_56362
  if(implementStrongReminderListComRespDto!= null&&  implementStrongReminderListComRespDto.getMessageList() !=null&& !CollectionUtil.isEmpty(implementStrongReminderListComRespDto.getMessageList())){
      implementDataAppointFormatShiftTextComReqDto.setDataAppointFormatShiftTextList(implementStrongReminderListComRespDto.getMessageList().stream().map(item->item.getMessageContent())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1401811_1_56362
    }
  
    /*D2执行强提醒内容列表转单字段[7515]   */
    Assert.isNull(implementDataAppointFormatShiftTextComReqDto.getCustomField1(),"D3执行智能指令沟通服务(公共)-D2执行强提醒内容列表转单字段-自定义字段1不能为空",false);
      implementDataAppointFormatShiftTextComRespDto = fwCompInterfaceModeClient.implementDataAppointFormatShiftTextCom(implementDataAppointFormatShiftTextComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
           }
QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    if(implementDeviceAcquisitionOrgPersonalInfoComRespDto !=null){
          com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("FORCING_ REMINDER_ COPY_ITEM");//CUSTOM_CONVENTION//sourceId:1401807_1_56361
queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1401808_1_56361
if(implementDeviceAcquisitionOrgPersonalInfoComRespDto!=null){
      queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1401806_1_56361
    }
  
    /*D2-3查强提醒基础文案[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(),"D3执行智能指令沟通服务(公共)-D2-3查强提醒基础文案-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D3执行智能指令沟通服务(公共)-D2-3查强提醒基础文案-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D3执行智能指令沟通服务(公共)-D2-3查强提醒基础文案-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
           }
ImplementRoboticSceneSemanticEngineComRespDto implementRoboticSceneSemanticEngineComRespDto_2 = null;
    if(queryConfItemMatchAnswerDetailComRespDto !=null&&implementDataAppointFormatShiftTextComRespDto !=null){
          ImplementRoboticSceneSemanticEngineComReqDto implementRoboticSceneSemanticEngineComReqDto_1=new ImplementRoboticSceneSemanticEngineComReqDto();
  implementRoboticSceneSemanticEngineComReqDto_1.setTemplateSemanticEngineCode("ASSEMBLY_STRONG_REMINDER_QUS_CONT_TEMP");//CUSTOM_CONVENTION//sourceId:1401776_1_56360
if(queryConfItemMatchAnswerDetailComRespDto!=null){
      implementRoboticSceneSemanticEngineComReqDto_1.setStrongReminderBasicCopy(queryConfItemMatchAnswerDetailComRespDto.getEndValue());//SimpleFieldAssign//sourceId:1401779_1_56360
    }
if(implementDataAppointFormatShiftTextComRespDto!=null){
      implementRoboticSceneSemanticEngineComReqDto_1.setStrongReminderContent(implementDataAppointFormatShiftTextComRespDto.getCustomText());//SimpleFieldAssign//sourceId:1401780_1_56360
    }
  
    /*D2组织强提醒提问内容[8112]   */
    Assert.isNull(implementRoboticSceneSemanticEngineComReqDto_1.getTemplateSemanticEngineCode(),"D3执行智能指令沟通服务(公共)-D2组织强提醒提问内容-模板引擎标识不能为空",false);
Assert.isNull(implementRoboticSceneSemanticEngineComReqDto_1.getStrongReminderBasicCopy(),"D3执行智能指令沟通服务(公共)-D2组织强提醒提问内容-强提醒部分内容不能为空",false);
Assert.isNull(implementRoboticSceneSemanticEngineComReqDto_1.getStrongReminderContent(),"D3执行智能指令沟通服务(公共)-D2组织强提醒提问内容-强提醒核心内容不能为空",false);
      implementRoboticSceneSemanticEngineComRespDto_2 = fwCompTemplateEngineClient.implementRoboticSceneSemanticEngineCom(implementRoboticSceneSemanticEngineComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;
      Assert.isTrue(implementRoboticSceneSemanticEngineComRespDto_2== null||  implementRoboticSceneSemanticEngineComRespDto_2.getObjectName() ==null,"找不到数据，系统异常",false);
      
      
           }
ImplementMutDataToOneDatasComRespDto implementMutDataToOneDatasComRespDto_2 = null;
    if(implementRoboticSceneSemanticEngineComRespDto_2 !=null){
          ImplementMutDataToOneDatasComReqDto implementMutDataToOneDatasComReqDto_1=new ImplementMutDataToOneDatasComReqDto();
  if(implementRoboticSceneSemanticEngineComRespDto_2!=null){
      implementMutDataToOneDatasComReqDto_1.setCustomField(implementRoboticSceneSemanticEngineComRespDto_2.getObjectName());//SimpleFieldAssign//sourceId:1400663_1_56365
    }
  
    /*D2执行输入消息内容单字段转数据集[5864]   */
    Assert.isNull(implementMutDataToOneDatasComReqDto_1.getCustomField(),"D3执行智能指令沟通服务(公共)-D2执行输入消息内容单字段转数据集-自定义字段不能为空",false);
      implementMutDataToOneDatasComRespDto_2 = fwCompInterfaceModeClient.implementMutDataToOneDatasCom(implementMutDataToOneDatasComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
           }
ImplementGuidedThirdPartyIntelligentQaComRespDto implementGuidedThirdPartyIntelligentQaComRespDto_2 = null;
    if(implementDeviceAcquisitionOrgPersonalInfoComRespDto !=null&&implementMutDataToOneDatasComRespDto_2 !=null){
          ImplementGuidedThirdPartyIntelligentQaComReqDto implementGuidedThirdPartyIntelligentQaComReqDto_1=new ImplementGuidedThirdPartyIntelligentQaComReqDto();
  implementGuidedThirdPartyIntelligentQaComReqDto_1.setBusModelVersion("PLUS_VERSION");//sourceId:2036980_1_56364
  if(implementDeviceAcquisitionOrgPersonalInfoComRespDto!=null){
      implementGuidedThirdPartyIntelligentQaComReqDto_1.setResultAspObjId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1400587_1_56364
    }
if(implementMutDataToOneDatasComRespDto_2!=null){
      //simpleList-to-objLists
    for (String item : implementMutDataToOneDatasComRespDto_2.getComDatasList()) {
                GetListIntelligentAnswersDto oneItem = new GetListIntelligentAnswersDto();
                oneItem.setRole("user");//sourceId:282040_2_56364
if(implementMutDataToOneDatasComRespDto_2!=null){
      oneItem.setContent(item);//SimpleFieldAssign//sourceId:282039_2_56364
    }
               
                implementGuidedThirdPartyIntelligentQaComReqDto_1.getGetListIntelligentAnswersList().add(oneItem);
            }//sourceId:1400588_1_56364
    }
  
    /*D2执行导向第三方智能问答(公共)[8103]   */
    Assert.isNull(implementGuidedThirdPartyIntelligentQaComReqDto_1.getResultAspObjId(),"D3执行智能指令沟通服务(公共)-D2执行导向第三方智能问答(公共)-开通对象ID不能为空",false);
Assert.isNull(implementGuidedThirdPartyIntelligentQaComReqDto_1.getBusModelVersion(),"D3执行智能指令沟通服务(公共)-D2执行导向第三方智能问答(公共)-业务模型版本不能为空",false);
      implementGuidedThirdPartyIntelligentQaComRespDto_2 = fwCompIntelligentCommunicationClient.implementGuidedThirdPartyIntelligentQaCom(implementGuidedThirdPartyIntelligentQaComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;
      Assert.isTrue(implementGuidedThirdPartyIntelligentQaComRespDto_2== null||  implementGuidedThirdPartyIntelligentQaComRespDto_2.getContent() ==null||implementGuidedThirdPartyIntelligentQaComRespDto_2== null||  implementGuidedThirdPartyIntelligentQaComRespDto_2.getRole() ==null,"找不到数据，系统异常",false);
      
      
           }
ImplementMarkdownTurnToTextComRespDto implementMarkdownTurnToTextComRespDto = null;
    if(implementGuidedThirdPartyIntelligentQaComRespDto_2 !=null){
          ImplementMarkdownTurnToTextComReqDto implementMarkdownTurnToTextComReqDto=new ImplementMarkdownTurnToTextComReqDto();
  if(implementGuidedThirdPartyIntelligentQaComRespDto_2!=null){
      implementMarkdownTurnToTextComReqDto.setMarkdownContent(implementGuidedThirdPartyIntelligentQaComRespDto_2.getContent());//SimpleFieldAssign//sourceId:1479353_1_59283
    }

    /*D2-执行markdown转文本(公共)[7517]   */
    Assert.isNull(implementMarkdownTurnToTextComReqDto.getMarkdownContent(),"D3执行智能指令沟通服务(公共)-D2-执行markdown转文本(公共)-markdown文本内容不能为空",false);
      implementMarkdownTurnToTextComRespDto = fwCompInterfaceModeClient.implementMarkdownTurnToTextCom(implementMarkdownTurnToTextComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//ModelCode: receptionService
        ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_2 = null;
    if(implementMarkdownTurnToTextComRespDto !=null){
          ImplementAcceptFieldByStandardDataReqDto receptionServiceReq_1=new ImplementAcceptFieldByStandardDataReqDto();
  if(implementMarkdownTurnToTextComRespDto!=null){
      receptionServiceReq_1.setContent(implementMarkdownTurnToTextComRespDto.getCustomText());//SimpleFieldAssign//sourceId:1404342_1_56435
    }
  
    /*M3-接收回答[7478]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getContent(),"D3执行智能指令沟通服务(公共)-M3-接收回答-消息内容不能为空",false);
      receptionServiceRes_2 = nbIntelligentCommunication.implementAcceptFieldByStandardData(receptionServiceReq_1);
      
      
      receptionServiceRes_3 = receptionServiceRes_2;
           }
      }
else if((implementManuallyParsingInstructionParametersComRespDto!= null&&  implementManuallyParsingInstructionParametersComRespDto.getCustomField() !=null && implementManuallyParsingInstructionParametersComRespDto.getCustomField().equals("QUESTION_ANSWER"))){
       //elseif(D2执行人工解析指令参数(公共).自定义字段 等于 想问答)  56349
      
ImplementWantAskAnswerComRespDto implementWantAskAnswerComRespDto = null;
    if(implementDeviceAcquisitionOrgPersonalInfoComRespDto !=null){
          ImplementWantAskAnswerComReqDto implementWantAskAnswerComReqDto=new ImplementWantAskAnswerComReqDto();
  implementWantAskAnswerComReqDto.setMsgChannelClassCode("INTELLIGENT_STUDY");//sourceId:1477059_1_56424
  implementWantAskAnswerComReqDto.setChannelTypeCode("THIRD_QA_SESSION");//sourceId:1403989_1_56424
implementWantAskAnswerComReqDto.setTableTypeCode("INTELLIGENT_HARDWARE_EQUIPMENT");//sourceId:1403990_1_56424
if(implementDeviceAcquisitionOrgPersonalInfoComRespDto!=null){
      implementWantAskAnswerComReqDto.setOriginalRoleMemberId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1403995_1_56424
implementWantAskAnswerComReqDto.setUserId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getUserId());//SimpleFieldAssign//sourceId:1403993_1_56424
implementWantAskAnswerComReqDto.setSpaceId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1403992_1_56424
implementWantAskAnswerComReqDto.setAppId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getAppId());//SimpleFieldAssign//sourceId:1403994_1_56424
    }
if(reqDto!=null){
      implementWantAskAnswerComReqDto.setContent(reqDto.getContent());//SimpleFieldAssign//sourceId:1403988_1_56424
implementWantAskAnswerComReqDto.setEntityId(reqDto.getSn());//SimpleFieldAssign//sourceId:1403991_1_56424
    }

    /*D3执行想问答(公共)[8125]   */
    Assert.isNull(implementWantAskAnswerComReqDto.getOriginalRoleMemberId(),"D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-身份人员ID不能为空",false);
Assert.isNull(implementWantAskAnswerComReqDto.getUserId(),"D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-个人账号ID不能为空",false);
Assert.isNull(implementWantAskAnswerComReqDto.getContent(),"D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-消息内容不能为空",false);
Assert.isNull(implementWantAskAnswerComReqDto.getMsgChannelClassCode(),"D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-消息使用通道类别不能为空",false);
Assert.isNull(implementWantAskAnswerComReqDto.getChannelTypeCode(),"D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-通道类型编码不能为空",false);
Assert.isNull(implementWantAskAnswerComReqDto.getTableTypeCode(),"D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-归属主体内容类型编码不能为空",false);
Assert.isNull(implementWantAskAnswerComReqDto.getEntityId(),"D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-归属主体内容ID不能为空",false);
Assert.isNull(implementWantAskAnswerComReqDto.getSpaceId(),"D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-创建于空间ID不能为空",false);
Assert.isNull(implementWantAskAnswerComReqDto.getAppId(),"D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-创建于联盟应用ID不能为空",false);
      implementWantAskAnswerComRespDto = implementWantAskAnswerCom(implementWantAskAnswerComReqDto)/*vcase invoke 同服务,同domain*/;



           }
ImplementMarkdownTurnToTextComRespDto implementMarkdownTurnToTextComRespDto_2 = null;
    if(implementWantAskAnswerComRespDto !=null){
          ImplementMarkdownTurnToTextComReqDto implementMarkdownTurnToTextComReqDto_1=new ImplementMarkdownTurnToTextComReqDto();
  if(implementWantAskAnswerComRespDto!=null){
      implementMarkdownTurnToTextComReqDto_1.setMarkdownContent(implementWantAskAnswerComRespDto.getContent());//SimpleFieldAssign//sourceId:1479353_1_59284
    }

    /*D2-执行markdown转文本(公共)[7517]   */
    Assert.isNull(implementMarkdownTurnToTextComReqDto_1.getMarkdownContent(),"D3执行智能指令沟通服务(公共)-D2-执行markdown转文本(公共)-markdown文本内容不能为空",false);
      implementMarkdownTurnToTextComRespDto_2 = fwCompInterfaceModeClient.implementMarkdownTurnToTextCom(implementMarkdownTurnToTextComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//ModelCode: receptionService
        ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_4 = null;
    if(implementMarkdownTurnToTextComRespDto_2 !=null){
          ImplementAcceptFieldByStandardDataReqDto receptionServiceReq_2=new ImplementAcceptFieldByStandardDataReqDto();
  if(implementMarkdownTurnToTextComRespDto_2!=null){
      receptionServiceReq_2.setContent(implementMarkdownTurnToTextComRespDto_2.getCustomText());//SimpleFieldAssign//sourceId:1404342_1_56434
    }

    /*M3-接收回答[7478]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getContent(),"D3执行智能指令沟通服务(公共)-M3-接收回答-消息内容不能为空",false);
      receptionServiceRes_4 = nbIntelligentCommunication.implementAcceptFieldByStandardData(receptionServiceReq_2);


      receptionServiceRes_3 = receptionServiceRes_4;
           }
    }
else if((implementManuallyParsingInstructionParametersComRespDto!= null&&  implementManuallyParsingInstructionParametersComRespDto.getCustomField() !=null && implementManuallyParsingInstructionParametersComRespDto.getCustomField().equals("INTELLIGENT_SERVICE"))){
       //elseif(D2执行人工解析指令参数(公共).自定义字段 等于 智能服务专业工作)  56350
      
ImplementWantAskAnswerComRespDto implementWantAskAnswerComRespDto_2 = null;
    if(implementDeviceAcquisitionOrgPersonalInfoComRespDto !=null){
          ImplementWantAskAnswerComReqDto implementWantAskAnswerComReqDto_1=new ImplementWantAskAnswerComReqDto();
  implementWantAskAnswerComReqDto_1.setMsgChannelClassCode("INTELLIGENT_STUDY");//sourceId:1477059_1_56428
  implementWantAskAnswerComReqDto_1.setChannelTypeCode("THIRD_QA_SESSION");//sourceId:1403989_1_56428
implementWantAskAnswerComReqDto_1.setTableTypeCode("INTELLIGENT_HARDWARE_EQUIPMENT");//sourceId:1403990_1_56428
if(implementDeviceAcquisitionOrgPersonalInfoComRespDto!=null){
      implementWantAskAnswerComReqDto_1.setOriginalRoleMemberId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1403995_1_56428
implementWantAskAnswerComReqDto_1.setUserId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getUserId());//SimpleFieldAssign//sourceId:1403993_1_56428
implementWantAskAnswerComReqDto_1.setSpaceId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1403992_1_56428
implementWantAskAnswerComReqDto_1.setAppId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getAppId());//SimpleFieldAssign//sourceId:1403994_1_56428
    }
if(reqDto!=null){
      implementWantAskAnswerComReqDto_1.setContent(reqDto.getContent());//SimpleFieldAssign//sourceId:1403988_1_56428
implementWantAskAnswerComReqDto_1.setEntityId(reqDto.getSn());//SimpleFieldAssign//sourceId:1403991_1_56428
    }

    /*D3执行想问答(公共)[8125]   */
    Assert.isNull(implementWantAskAnswerComReqDto_1.getOriginalRoleMemberId(),"D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-身份人员ID不能为空",false);
Assert.isNull(implementWantAskAnswerComReqDto_1.getUserId(),"D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-个人账号ID不能为空",false);
Assert.isNull(implementWantAskAnswerComReqDto_1.getContent(),"D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-消息内容不能为空",false);
Assert.isNull(implementWantAskAnswerComReqDto_1.getMsgChannelClassCode(),"D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-消息使用通道类别不能为空",false);
Assert.isNull(implementWantAskAnswerComReqDto_1.getChannelTypeCode(),"D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-通道类型编码不能为空",false);
Assert.isNull(implementWantAskAnswerComReqDto_1.getTableTypeCode(),"D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-归属主体内容类型编码不能为空",false);
Assert.isNull(implementWantAskAnswerComReqDto_1.getEntityId(),"D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-归属主体内容ID不能为空",false);
Assert.isNull(implementWantAskAnswerComReqDto_1.getSpaceId(),"D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-创建于空间ID不能为空",false);
Assert.isNull(implementWantAskAnswerComReqDto_1.getAppId(),"D3执行智能指令沟通服务(公共)-D3执行想问答(公共)-创建于联盟应用ID不能为空",false);
      implementWantAskAnswerComRespDto_2 = implementWantAskAnswerCom(implementWantAskAnswerComReqDto_1)/*vcase invoke 同服务,同domain*/;



           }
ImplementMarkdownTurnToTextComRespDto implementMarkdownTurnToTextComRespDto_3 = null;
    if(implementWantAskAnswerComRespDto_2 !=null){
          ImplementMarkdownTurnToTextComReqDto implementMarkdownTurnToTextComReqDto_2=new ImplementMarkdownTurnToTextComReqDto();
  if(implementWantAskAnswerComRespDto_2!=null){
      implementMarkdownTurnToTextComReqDto_2.setMarkdownContent(implementWantAskAnswerComRespDto_2.getContent());//SimpleFieldAssign//sourceId:1479353_1_59285
    }

    /*D2-执行markdown转文本(公共)[7517]   */
    Assert.isNull(implementMarkdownTurnToTextComReqDto_2.getMarkdownContent(),"D3执行智能指令沟通服务(公共)-D2-执行markdown转文本(公共)-markdown文本内容不能为空",false);
      implementMarkdownTurnToTextComRespDto_3 = fwCompInterfaceModeClient.implementMarkdownTurnToTextCom(implementMarkdownTurnToTextComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//ModelCode: receptionService
        ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_5 = null;
    if(implementMarkdownTurnToTextComRespDto_3 !=null){
          ImplementAcceptFieldByStandardDataReqDto receptionServiceReq_3=new ImplementAcceptFieldByStandardDataReqDto();
  if(implementMarkdownTurnToTextComRespDto_3!=null){
      receptionServiceReq_3.setContent(implementMarkdownTurnToTextComRespDto_3.getCustomText());//SimpleFieldAssign//sourceId:1404342_1_56433
    }

    /*M3-接收回答[7478]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getContent(),"D3执行智能指令沟通服务(公共)-M3-接收回答-消息内容不能为空",false);
      receptionServiceRes_5 = nbIntelligentCommunication.implementAcceptFieldByStandardData(receptionServiceReq_3);


      receptionServiceRes_3 = receptionServiceRes_5;
           }
    }
else if((implementManuallyParsingInstructionParametersComRespDto!= null&&  implementManuallyParsingInstructionParametersComRespDto.getCustomField() !=null && implementManuallyParsingInstructionParametersComRespDto.getCustomField().equals("RAISE_QUESTION"))){
       //elseif(D2执行人工解析指令参数(公共).自定义字段 等于 提出问题)  56351

QueryUserInfoDetailComRespDto queryUserInfoDetailComRespDto = null;
    if(implementManuallyParsingInstructionParametersComRespDto !=null){
          QueryUserInfoDetailComReqDto queryUserInfoDetailComReqDto=new QueryUserInfoDetailComReqDto();
  if(implementManuallyParsingInstructionParametersComRespDto!=null){
      queryUserInfoDetailComReqDto.setIdCardName(implementManuallyParsingInstructionParametersComRespDto.getCustomField3());//SimpleFieldAssign//sourceId:1403640_1_56388
    }
  
    /*D1-2查询任务问题负责人[408]   */
    Assert.isNull(queryUserInfoDetailComReqDto.getIdCardName(),"D3执行智能指令沟通服务(公共)-D1-2查询任务问题负责人-真实姓名不能为空",false);
      queryUserInfoDetailComRespDto = fwBaseUserClient.queryUserInfoDetailCom(queryUserInfoDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
           }
if((queryUserInfoDetailComRespDto!= null&& queryUserInfoDetailComRespDto.getUserId() == null )) {
        //if(D1-2查询问题负责人个人账号（用于查询就职记录及接收部门ID）.账号 值等于空 )  59119

//异常结束 59120
      throw new BizException("C00278","没有找到问题负责人，请提出问题注意负责人的真实姓名～",false);
           }
QueryInductionDeptDetailComRespDto queryInductionDeptDetailComRespDto_2 = null;
    if(queryUserInfoDetailComRespDto !=null&&implementDeviceAcquisitionOrgPersonalInfoComRespDto !=null){
          QueryInductionDeptDetailComReqDto queryInductionDeptDetailComReqDto_1=new QueryInductionDeptDetailComReqDto();
  queryInductionDeptDetailComReqDto_1.setInductionUnitTypeCode("DEPT");//sourceId:1403614_1_56391
queryInductionDeptDetailComReqDto_1.setIsMainInduction("TRUE");//sourceId:1402946_1_56391
queryInductionDeptDetailComReqDto_1.setIsTransaction("FALSE");//sourceId:1402947_1_56391
queryInductionDeptDetailComReqDto_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1402948_1_56391
if(queryUserInfoDetailComRespDto!=null){
      queryInductionDeptDetailComReqDto_1.setUserId(queryUserInfoDetailComRespDto.getUserId());//SimpleFieldAssign//sourceId:1403654_1_56391
    }
if(implementDeviceAcquisitionOrgPersonalInfoComRespDto!=null){
      queryInductionDeptDetailComReqDto_1.setSpaceId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1402929_1_56391
    }
  
    /*D1查询就职的部门详情(公共)[7829]   */
    Assert.isNull(queryInductionDeptDetailComReqDto_1.getUserId(),"D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-个人账号ID不能为空",false);
Assert.isNull(queryInductionDeptDetailComReqDto_1.getInductionUnitTypeCode(),"D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-就职单位类型实例不能为空",false);
Assert.isNull(queryInductionDeptDetailComReqDto_1.getIsMainInduction(),"D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-是否主岗不能为空",false);
Assert.isNull(queryInductionDeptDetailComReqDto_1.getIsTransaction(),"D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-是否异动不能为空",false);
Assert.isNull(queryInductionDeptDetailComReqDto_1.getSubjectLifeCycle(),"D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-主体生命周期不能为空",false);
Assert.isNull(queryInductionDeptDetailComReqDto_1.getSpaceId(),"D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-创建于空间ID不能为空",false);
      queryInductionDeptDetailComRespDto_2 = fwBaseInductionRecordClient.queryInductionDeptDetailCom(queryInductionDeptDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
           }
AddQuestionBusinessProcessingComRespDto addQuestionBusinessProcessingComRespDto = null;
    if(implementManuallyParsingInstructionParametersComRespDto !=null&&queryInductionDeptDetailComRespDto !=null&&queryInductionDeptDetailComRespDto_2 !=null){
          AddQuestionBusinessProcessingComReqDto addQuestionBusinessProcessingComReqDto=new AddQuestionBusinessProcessingComReqDto();
  addQuestionBusinessProcessingComReqDto.setArrangeSubjectTypeCode("OMS_ORG_DEPT");//sourceId:1402984_1_56378
addQuestionBusinessProcessingComReqDto.setCoordObjectTypeCode("OMS_ORG_DEPT");//sourceId:1402985_1_56378
addQuestionBusinessProcessingComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1402993_1_56378
if(implementManuallyParsingInstructionParametersComRespDto!=null){
      addQuestionBusinessProcessingComReqDto.setQuestionIntroduce(implementManuallyParsingInstructionParametersComRespDto.getCustomField1());//SimpleFieldAssign//sourceId:1402979_1_56378
addQuestionBusinessProcessingComReqDto.setQuestionDesc(implementManuallyParsingInstructionParametersComRespDto.getCustomField5());//SimpleFieldAssign//sourceId:1402980_1_56378
addQuestionBusinessProcessingComReqDto.setQuestionLevel(implementManuallyParsingInstructionParametersComRespDto.getCustomField4());//SimpleFieldAssign//sourceId:1402981_1_56378
    }
if(queryInductionDeptDetailComRespDto!=null){
      addQuestionBusinessProcessingComReqDto.setArrangeSubjectId(queryInductionDeptDetailComRespDto.getEntityId());//SimpleFieldAssign//sourceId:1402983_1_56378
addQuestionBusinessProcessingComReqDto.setCoordObjectId(queryInductionDeptDetailComRespDto.getEntityId());//SimpleFieldAssign//sourceId:1402986_1_56378
addQuestionBusinessProcessingComReqDto.setCreateInductionId(queryInductionDeptDetailComRespDto.getInductionRecordId());//SimpleFieldAssign//sourceId:1403631_1_56378
    }
if(queryInductionDeptDetailComRespDto_2!=null){
      addQuestionBusinessProcessingComReqDto.setPrincipalInductionId(queryInductionDeptDetailComRespDto_2.getInductionRecordId());//SimpleFieldAssign//sourceId:1402996_1_56378
    }
  
    /*D3新增问题业务处理(公共)[7854]   */
    Assert.isNull(addQuestionBusinessProcessingComReqDto.getQuestionIntroduce(),"D3执行智能指令沟通服务(公共)-D3新增问题业务处理(公共)-问题文字简介不能为空",false);
Assert.isNull(addQuestionBusinessProcessingComReqDto.getQuestionDesc(),"D3执行智能指令沟通服务(公共)-D3新增问题业务处理(公共)-问题文字描述不能为空",false);
Assert.isNull(addQuestionBusinessProcessingComReqDto.getQuestionLevel(),"D3执行智能指令沟通服务(公共)-D3新增问题业务处理(公共)-问题等级不能为空",false);
Assert.isNull(addQuestionBusinessProcessingComReqDto.getArrangeSubjectId(),"D3执行智能指令沟通服务(公共)-D3新增问题业务处理(公共)-安排主体ID不能为空",false);
Assert.isNull(addQuestionBusinessProcessingComReqDto.getArrangeSubjectTypeCode(),"D3执行智能指令沟通服务(公共)-D3新增问题业务处理(公共)-安排主体类型编码不能为空",false);
Assert.isNull(addQuestionBusinessProcessingComReqDto.getCoordObjectTypeCode(),"D3执行智能指令沟通服务(公共)-D3新增问题业务处理(公共)-归属对象类型编码不能为空",false);
Assert.isNull(addQuestionBusinessProcessingComReqDto.getCoordObjectId(),"D3执行智能指令沟通服务(公共)-D3新增问题业务处理(公共)-归属对象ID不能为空",false);
Assert.isNull(addQuestionBusinessProcessingComReqDto.getCreateInductionId(),"D3执行智能指令沟通服务(公共)-D3新增问题业务处理(公共)-创建人就职记录ID不能为空",false);
Assert.isNull(addQuestionBusinessProcessingComReqDto.getPrincipalInductionId(),"D3执行智能指令沟通服务(公共)-D3新增问题业务处理(公共)-负责人就职记录ID不能为空",false);
Assert.isNull(addQuestionBusinessProcessingComReqDto.getSubjectLifeCycle(),"D3执行智能指令沟通服务(公共)-D3新增问题业务处理(公共)-主体生命周期不能为空",false);
      addQuestionBusinessProcessingComRespDto = questionService.addQuestionBusinessProcessingCom(addQuestionBusinessProcessingComReqDto)/*vcase invoke isSameApp*/;
      Assert.isTrue(addQuestionBusinessProcessingComRespDto== null||  addQuestionBusinessProcessingComRespDto.getQuestionId() ==null,"找不到数据，系统异常",false);
      
      
           }
//ModelCode: receptionService
        ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_6 = null;
    ImplementAcceptFieldByStandardDataReqDto receptionServiceReq_4=new ImplementAcceptFieldByStandardDataReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_4.setContent(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1404342_1_56432
    }
  
    /*M3-接收回答[7478]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_4.getContent(),"D3执行智能指令沟通服务(公共)-M3-接收回答-消息内容不能为空",false);
      receptionServiceRes_6 = nbIntelligentCommunication.implementAcceptFieldByStandardData(receptionServiceReq_4);
      
      
      receptionServiceRes_3 = receptionServiceRes_6;
    }
else if((implementManuallyParsingInstructionParametersComRespDto!= null&&  implementManuallyParsingInstructionParametersComRespDto.getCustomField() !=null && implementManuallyParsingInstructionParametersComRespDto.getCustomField().equals("ASSIGN_TASK"))){
       //elseif(D2执行人工解析指令参数(公共).自定义字段 等于 安排任务)  56352

QueryUserInfoDetailComRespDto queryUserInfoDetailComRespDto_2 = null;
    if(implementManuallyParsingInstructionParametersComRespDto !=null){
          QueryUserInfoDetailComReqDto queryUserInfoDetailComReqDto_1=new QueryUserInfoDetailComReqDto();
  if(implementManuallyParsingInstructionParametersComRespDto!=null){
      queryUserInfoDetailComReqDto_1.setIdCardName(implementManuallyParsingInstructionParametersComRespDto.getCustomField3());//SimpleFieldAssign//sourceId:1403640_1_56389
    }
  
    /*D1-2查询任务问题负责人[408]   */
    Assert.isNull(queryUserInfoDetailComReqDto_1.getIdCardName(),"D3执行智能指令沟通服务(公共)-D1-2查询任务问题负责人-真实姓名不能为空",false);
      queryUserInfoDetailComRespDto_2 = fwBaseUserClient.queryUserInfoDetailCom(queryUserInfoDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
           }
if((queryUserInfoDetailComRespDto_2!= null&& queryUserInfoDetailComRespDto_2.getUserId() == null )) {
        //if(D1-2查询任务负责人（用于查询就职记录及接收部门ID）.账号 值等于空 )  59117

//异常结束 59118
      throw new BizException("C00277","没有找到任务负责人，请重新安排时候注意负责人的真实姓名～",false);
           }
QueryInductionDeptDetailComRespDto queryInductionDeptDetailComRespDto_3 = null;
    if(queryUserInfoDetailComRespDto_2 !=null&&implementDeviceAcquisitionOrgPersonalInfoComRespDto !=null){
          QueryInductionDeptDetailComReqDto queryInductionDeptDetailComReqDto_2=new QueryInductionDeptDetailComReqDto();
  queryInductionDeptDetailComReqDto_2.setInductionUnitTypeCode("DEPT");//sourceId:1403614_1_56390
queryInductionDeptDetailComReqDto_2.setIsMainInduction("TRUE");//sourceId:1402946_1_56390
queryInductionDeptDetailComReqDto_2.setIsTransaction("FALSE");//sourceId:1402947_1_56390
queryInductionDeptDetailComReqDto_2.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1402948_1_56390
if(queryUserInfoDetailComRespDto_2!=null){
      queryInductionDeptDetailComReqDto_2.setUserId(queryUserInfoDetailComRespDto_2.getUserId());//SimpleFieldAssign//sourceId:1403654_1_56390
    }
if(implementDeviceAcquisitionOrgPersonalInfoComRespDto!=null){
      queryInductionDeptDetailComReqDto_2.setSpaceId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1402929_1_56390
    }
  
    /*D1查询就职的部门详情(公共)[7829]   */
    Assert.isNull(queryInductionDeptDetailComReqDto_2.getUserId(),"D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-个人账号ID不能为空",false);
Assert.isNull(queryInductionDeptDetailComReqDto_2.getInductionUnitTypeCode(),"D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-就职单位类型实例不能为空",false);
Assert.isNull(queryInductionDeptDetailComReqDto_2.getIsMainInduction(),"D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-是否主岗不能为空",false);
Assert.isNull(queryInductionDeptDetailComReqDto_2.getIsTransaction(),"D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-是否异动不能为空",false);
Assert.isNull(queryInductionDeptDetailComReqDto_2.getSubjectLifeCycle(),"D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-主体生命周期不能为空",false);
Assert.isNull(queryInductionDeptDetailComReqDto_2.getSpaceId(),"D3执行智能指令沟通服务(公共)-D1查询就职的部门详情(公共)-创建于空间ID不能为空",false);
      queryInductionDeptDetailComRespDto_3 = fwBaseInductionRecordClient.queryInductionDeptDetailCom(queryInductionDeptDetailComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
           }
AddIndependentTaskBusinessProcessingComRespDto addIndependentTaskBusinessProcessingComRespDto = null;
    if(implementManuallyParsingInstructionParametersComRespDto !=null&&queryInductionDeptDetailComRespDto !=null&&queryInductionDeptDetailComRespDto_3 !=null){
          AddIndependentTaskBusinessProcessingComReqDto addIndependentTaskBusinessProcessingComReqDto=new AddIndependentTaskBusinessProcessingComReqDto();
  addIndependentTaskBusinessProcessingComReqDto.setTaskType("ROUTINE_TASK");//sourceId:1403586_1_56384
addIndependentTaskBusinessProcessingComReqDto.setWorkTaskType("INDEPENDENT_TASK");//sourceId:1403613_1_56384
addIndependentTaskBusinessProcessingComReqDto.setArrangeSubjectTypeCode("OMS_ORG_DEPT");//sourceId:1403588_1_56384
addIndependentTaskBusinessProcessingComReqDto.setCoordObjectTypeCode("OMS_ORG_DEPT");//sourceId:1403596_1_56384
addIndependentTaskBusinessProcessingComReqDto.setPlanStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1403598_1_56384
addIndependentTaskBusinessProcessingComReqDto.setSourceTypeCode("CONVENTIONAL_WORK_TASKS");//CUSTOM_CONVENTION//sourceId:1403600_1_56384
addIndependentTaskBusinessProcessingComReqDto.setIsSystemTask("FALSE");//sourceId:1403607_1_56384
addIndependentTaskBusinessProcessingComReqDto.setIsSystemComplete("FALSE");//sourceId:1403608_1_56384
addIndependentTaskBusinessProcessingComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1403602_1_56384
addIndependentTaskBusinessProcessingComReqDto.setMessageImportantLevel(Long.valueOf(4));//CUSTOM_CONVENTION//sourceId:1403609_1_56384
if(implementManuallyParsingInstructionParametersComRespDto!=null){
      addIndependentTaskBusinessProcessingComReqDto.setTaskName(implementManuallyParsingInstructionParametersComRespDto.getCustomField1());//SimpleFieldAssign//sourceId:1403584_1_56384
addIndependentTaskBusinessProcessingComReqDto.setTaskDesc(implementManuallyParsingInstructionParametersComRespDto.getCustomField5());//SimpleFieldAssign//sourceId:1403603_1_56384
addIndependentTaskBusinessProcessingComReqDto.setPlanEndTime(implementManuallyParsingInstructionParametersComRespDto.getCustomField4()!=null?CommonFunctionHelper.str2Date(implementManuallyParsingInstructionParametersComRespDto.getCustomField4()):null);//SimpleFieldAssign//sourceId:1403599_1_56384
    }
if(queryInductionDeptDetailComRespDto!=null){
      addIndependentTaskBusinessProcessingComReqDto.setArrangeSubjectId(queryInductionDeptDetailComRespDto.getEntityId());//SimpleFieldAssign//sourceId:1403587_1_56384
addIndependentTaskBusinessProcessingComReqDto.setCoordObjectId(queryInductionDeptDetailComRespDto.getEntityId());//SimpleFieldAssign//sourceId:1403597_1_56384
addIndependentTaskBusinessProcessingComReqDto.setReportObjectInductionRecordId(queryInductionDeptDetailComRespDto.getInductionRecordId());//SimpleFieldAssign//sourceId:1403601_1_56384
    }
if(queryInductionDeptDetailComRespDto_3!=null){
      addIndependentTaskBusinessProcessingComReqDto.setReceiveSubjectId(queryInductionDeptDetailComRespDto_3.getEntityId());//SimpleFieldAssign//sourceId:1403589_1_56384
addIndependentTaskBusinessProcessingComReqDto.setPrincipalInductionId(queryInductionDeptDetailComRespDto_3.getInductionRecordId());//SimpleFieldAssign//sourceId:1403605_1_56384
    }
  
    /*D3-新增独立任务（或子任务）业务处理(公共)[7853]   */
    Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getTaskName(),"D3执行智能指令沟通服务(公共)-D3-新增独立任务（或子任务）业务处理(公共)-任务名称不能为空",false);
Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getTaskDesc(),"D3执行智能指令沟通服务(公共)-D3-新增独立任务（或子任务）业务处理(公共)-任务简介不能为空",false);
Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getTaskType(),"D3执行智能指令沟通服务(公共)-D3-新增独立任务（或子任务）业务处理(公共)-任务类型不能为空",false);
Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getWorkTaskType(),"D3执行智能指令沟通服务(公共)-D3-新增独立任务（或子任务）业务处理(公共)-工作任务类别不能为空",false);
Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getArrangeSubjectId(),"D3执行智能指令沟通服务(公共)-D3-新增独立任务（或子任务）业务处理(公共)-安排主体ID不能为空",false);
Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getArrangeSubjectTypeCode(),"D3执行智能指令沟通服务(公共)-D3-新增独立任务（或子任务）业务处理(公共)-安排主体类型编码不能为空",false);
Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getCoordObjectTypeCode(),"D3执行智能指令沟通服务(公共)-D3-新增独立任务（或子任务）业务处理(公共)-归属对象类型编码不能为空",false);
Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getCoordObjectId(),"D3执行智能指令沟通服务(公共)-D3-新增独立任务（或子任务）业务处理(公共)-归属对象ID不能为空",false);
Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getPlanStartTime(),"D3执行智能指令沟通服务(公共)-D3-新增独立任务（或子任务）业务处理(公共)-计划开始时间不能为空",false);
Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getPlanEndTime(),"D3执行智能指令沟通服务(公共)-D3-新增独立任务（或子任务）业务处理(公共)-计划结束时间不能为空",false);
Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getSourceTypeCode(),"D3执行智能指令沟通服务(公共)-D3-新增独立任务（或子任务）业务处理(公共)-来源类型编码不能为空",false);
Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getReportObjectInductionRecordId(),"D3执行智能指令沟通服务(公共)-D3-新增独立任务（或子任务）业务处理(公共)-汇报对象就职记录ID不能为空",false);
Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getIsSystemTask(),"D3执行智能指令沟通服务(公共)-D3-新增独立任务（或子任务）业务处理(公共)-是否系统任务不能为空",false);
Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getIsSystemComplete(),"D3执行智能指令沟通服务(公共)-D3-新增独立任务（或子任务）业务处理(公共)-是否系统完成不能为空",false);
Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getSubjectLifeCycle(),"D3执行智能指令沟通服务(公共)-D3-新增独立任务（或子任务）业务处理(公共)-主体生命周期不能为空",false);
Assert.isNull(addIndependentTaskBusinessProcessingComReqDto.getMessageImportantLevel(),"D3执行智能指令沟通服务(公共)-D3-新增独立任务（或子任务）业务处理(公共)-消息重要紧急度层级不能为空",false);
      addIndependentTaskBusinessProcessingComRespDto = workTasksService.addIndependentTaskBusinessProcessingCom(addIndependentTaskBusinessProcessingComReqDto)/*vcase invoke isSameApp*/;
      
      
      
           }
//ModelCode: receptionService
        ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_7 = null;
    ImplementAcceptFieldByStandardDataReqDto receptionServiceReq_5=new ImplementAcceptFieldByStandardDataReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_5.setContent(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1404342_1_56431
    }
  
    /*M3-接收回答[7478]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_5.getContent(),"D3执行智能指令沟通服务(公共)-M3-接收回答-消息内容不能为空",false);
      receptionServiceRes_7 = nbIntelligentCommunication.implementAcceptFieldByStandardData(receptionServiceReq_5);
      
      
      receptionServiceRes_3 = receptionServiceRes_7;
    }
else if((implementManuallyParsingInstructionParametersComRespDto!= null&&  implementManuallyParsingInstructionParametersComRespDto.getCustomField() !=null && implementManuallyParsingInstructionParametersComRespDto.getCustomField().equals("RECORD_IDEAS"))){
       //elseif(D2执行人工解析指令参数(公共).自定义字段 等于 记录创意想法)  59268

ImplementRecordIdeasComRespDto implementRecordIdeasComRespDto = null;
    if(implementDeviceAcquisitionOrgPersonalInfoComRespDto !=null&&queryInductionDeptDetailComRespDto !=null){
          ImplementRecordIdeasComReqDto implementRecordIdeasComReqDto=new ImplementRecordIdeasComReqDto();
  implementRecordIdeasComReqDto.setCustomField("1");//CUSTOM_CONVENTION//sourceId:1495348_1_59276
  if(reqDto!=null){
      implementRecordIdeasComReqDto.setContent(reqDto.getContent());//SimpleFieldAssign//sourceId:1479340_1_59276
    }
if(implementDeviceAcquisitionOrgPersonalInfoComRespDto!=null){
      implementRecordIdeasComReqDto.setOriginalRoleMemberId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1479336_1_59276
implementRecordIdeasComReqDto.setUserId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getUserId());//SimpleFieldAssign//sourceId:1479337_1_59276
implementRecordIdeasComReqDto.setSpaceId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1479338_1_59276
implementRecordIdeasComReqDto.setAppId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getAppId());//SimpleFieldAssign//sourceId:1479339_1_59276
    }
if(queryInductionDeptDetailComRespDto!=null){
      implementRecordIdeasComReqDto.setCreateInductionId(queryInductionDeptDetailComRespDto.getInductionRecordId());//SimpleFieldAssign//sourceId:1479352_1_59276
    }

    /*D3执行记录创意想法(公共)[8289]   */
    Assert.isNull(implementRecordIdeasComReqDto.getCustomField(),"D3执行智能指令沟通服务(公共)-D3执行记录创意想法(公共)-自定义字段不能为空",false);
Assert.isNull(implementRecordIdeasComReqDto.getContent(),"D3执行智能指令沟通服务(公共)-D3执行记录创意想法(公共)-消息内容不能为空",false);
Assert.isNull(implementRecordIdeasComReqDto.getOriginalRoleMemberId(),"D3执行智能指令沟通服务(公共)-D3执行记录创意想法(公共)-身份人员ID不能为空",false);
Assert.isNull(implementRecordIdeasComReqDto.getUserId(),"D3执行智能指令沟通服务(公共)-D3执行记录创意想法(公共)-账号ID不能为空",false);
Assert.isNull(implementRecordIdeasComReqDto.getCreateInductionId(),"D3执行智能指令沟通服务(公共)-D3执行记录创意想法(公共)-创建人就职记录ID不能为空",false);
Assert.isNull(implementRecordIdeasComReqDto.getSpaceId(),"D3执行智能指令沟通服务(公共)-D3执行记录创意想法(公共)-创建于空间ID不能为空",false);
Assert.isNull(implementRecordIdeasComReqDto.getAppId(),"D3执行智能指令沟通服务(公共)-D3执行记录创意想法(公共)-创建于联盟应用ID不能为空",false);
      implementRecordIdeasComRespDto = implementRecordIdeasCom(implementRecordIdeasComReqDto)/*vcase invoke 同服务,同domain*/;



           }
//ModelCode: receptionService
        ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_8 = null;
    ImplementAcceptFieldByStandardDataReqDto receptionServiceReq_6=new ImplementAcceptFieldByStandardDataReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_6.setContent(receptionServiceRes.getCustomField3());//SimpleFieldAssign//sourceId:1404342_1_59277
    }

    /*M3-接收回答[7478]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_6.getContent(),"D3执行智能指令沟通服务(公共)-M3-接收回答-消息内容不能为空",false);
      receptionServiceRes_8 = nbIntelligentCommunication.implementAcceptFieldByStandardData(receptionServiceReq_6);


      receptionServiceRes_3 = receptionServiceRes_8;
    }
else if((implementManuallyParsingInstructionParametersComRespDto!= null&&  implementManuallyParsingInstructionParametersComRespDto.getCustomField() !=null && implementManuallyParsingInstructionParametersComRespDto.getCustomField().equals("RECORD_MESSAGE"))){
       //elseif(D2执行人工解析指令参数(公共).自定义字段 等于 记录重要笔记)  59990

ImplementRecordIdeasComRespDto implementRecordIdeasComRespDto_1 = null;
    if(implementDeviceAcquisitionOrgPersonalInfoComRespDto !=null&&queryInductionDeptDetailComRespDto !=null){
          ImplementRecordIdeasComReqDto implementRecordIdeasComReqDto_1=new ImplementRecordIdeasComReqDto();
  implementRecordIdeasComReqDto_1.setCustomField("2");//CUSTOM_CONVENTION//sourceId:1495355_1_59991
if(reqDto!=null){
      implementRecordIdeasComReqDto_1.setContent(reqDto.getContent());//SimpleFieldAssign//sourceId:1495353_1_59991
    }
if(implementDeviceAcquisitionOrgPersonalInfoComRespDto!=null){
      implementRecordIdeasComReqDto_1.setOriginalRoleMemberId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1495349_1_59991
implementRecordIdeasComReqDto_1.setUserId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getUserId());//SimpleFieldAssign//sourceId:1495350_1_59991
implementRecordIdeasComReqDto_1.setSpaceId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1495351_1_59991
implementRecordIdeasComReqDto_1.setAppId(implementDeviceAcquisitionOrgPersonalInfoComRespDto.getAppId());//SimpleFieldAssign//sourceId:1495352_1_59991
    }
if(queryInductionDeptDetailComRespDto!=null){
      implementRecordIdeasComReqDto_1.setCreateInductionId(queryInductionDeptDetailComRespDto.getInductionRecordId());//SimpleFieldAssign//sourceId:1495354_1_59991
    }

    /*D3执行记录重要笔记(公共)[8289]   */
    Assert.isNull(implementRecordIdeasComReqDto_1.getCustomField(),"D3执行智能指令沟通服务(公共)-D3执行记录重要笔记(公共)-自定义字段不能为空",false);
Assert.isNull(implementRecordIdeasComReqDto_1.getContent(),"D3执行智能指令沟通服务(公共)-D3执行记录重要笔记(公共)-消息内容不能为空",false);
Assert.isNull(implementRecordIdeasComReqDto_1.getOriginalRoleMemberId(),"D3执行智能指令沟通服务(公共)-D3执行记录重要笔记(公共)-身份人员ID不能为空",false);
Assert.isNull(implementRecordIdeasComReqDto_1.getUserId(),"D3执行智能指令沟通服务(公共)-D3执行记录重要笔记(公共)-账号ID不能为空",false);
Assert.isNull(implementRecordIdeasComReqDto_1.getCreateInductionId(),"D3执行智能指令沟通服务(公共)-D3执行记录重要笔记(公共)-创建人就职记录ID不能为空",false);
Assert.isNull(implementRecordIdeasComReqDto_1.getSpaceId(),"D3执行智能指令沟通服务(公共)-D3执行记录重要笔记(公共)-创建于空间ID不能为空",false);
Assert.isNull(implementRecordIdeasComReqDto_1.getAppId(),"D3执行智能指令沟通服务(公共)-D3执行记录重要笔记(公共)-创建于联盟应用ID不能为空",false);
      implementRecordIdeasComRespDto_1 = implementRecordIdeasCom(implementRecordIdeasComReqDto_1)/*vcase invoke 同服务,同domain*/;



           }
//ModelCode: receptionService
        ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_9 = null;
    ImplementAcceptFieldByStandardDataReqDto receptionServiceReq_7=new ImplementAcceptFieldByStandardDataReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_7.setContent(receptionServiceRes.getCustomField4());//SimpleFieldAssign//sourceId:1404342_1_59992
    }

    /*M3-接收回答[7478]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_7.getContent(),"D3执行智能指令沟通服务(公共)-M3-接收回答-消息内容不能为空",false);
      receptionServiceRes_9 = nbIntelligentCommunication.implementAcceptFieldByStandardData(receptionServiceReq_7);


      receptionServiceRes_3 = receptionServiceRes_9;
    }
else{
       //else  56355
      
//异常结束 56356
      throw new BizException("C00275","无效指令，请您再重新说一下～",false);
    }
ImplementIntelligentCommandCommunicationServicesComRespDto retData = new ImplementIntelligentCommandCommunicationServicesComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setContent(receptionServiceRes_3.getContent());//SimpleFieldAssign//sourceId:1404695_1
    }
  

  
  
return retData;
  }
/**
   * D3执行想问答(公共)[8125]
   * gen by moon at 12/13/2024, 11:13:14 PM
   */
  @Trace(operationName = "D3执行想问答(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementWantAskAnswerComRespDto implementWantAskAnswerCom(ImplementWantAskAnswerComReqDto reqDto){


      ImplementGuidedThirdPartyIntelligentQaComRespDto implementGuidedThirdPartyIntelligentQaComRespDto_1 =null;
//virtualUsage D1-2查询发送方头像姓名  56393
      QueryUserInfoDetailComRespDto queryUserInfoDetailComRespDto = null;
    QueryUserInfoDetailComReqDto queryUserInfoDetailComReqDto=new QueryUserInfoDetailComReqDto();
  if(reqDto!=null){
      queryUserInfoDetailComReqDto.setUserId(reqDto.getUserId());//SimpleFieldAssign//sourceId:1403699_1_56393
    }

    /*D1-2查询发送方头像姓名[408]   */
    Assert.isNull(queryUserInfoDetailComReqDto.getUserId(),"D3执行想问答(公共)-D1-2查询发送方头像姓名-账号不能为空",false);
      queryUserInfoDetailComRespDto = fwBaseUserClient.queryUserInfoDetailCom(queryUserInfoDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      Assert.isTrue(queryUserInfoDetailComRespDto== null||  queryUserInfoDetailComRespDto.getUserFace() ==null||queryUserInfoDetailComRespDto== null||  queryUserInfoDetailComRespDto.getIdCardName() ==null,"找不到数据，系统异常",false);


if((queryUserInfoDetailComRespDto!= null&& queryUserInfoDetailComRespDto.getUserId() != null )) {
        //if(D1-2查询发送方头像姓名.账号 值不等于空 )  56394

QueryAppDetailComRespDto queryAppDetailComRespDto = null;
    QueryAppDetailComReqDto queryAppDetailComReqDto=new QueryAppDetailComReqDto();
  if(reqDto!=null){
      queryAppDetailComReqDto.setUniqueSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1403841_1_56397
    }

    /*D1-2查询小助手身份人员ID[3268]   */
    Assert.isNull(queryAppDetailComReqDto.getUniqueSpaceId(),"D3执行想问答(公共)-D1-2查询小助手身份人员ID-管理的空间ID不能为空",false);
      queryAppDetailComRespDto = fwBaseBaseClient.queryAppDetailCom(queryAppDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      Assert.isTrue(queryAppDetailComRespDto== null||  queryAppDetailComRespDto.getSenderMemberId() ==null,"找不到数据，系统异常",false);


QueryMemberProfileDetailComRespDto queryMemberProfileDetailComRespDto = null;
    if(queryAppDetailComRespDto !=null){
          QueryMemberProfileDetailComReqDto queryMemberProfileDetailComReqDto=new QueryMemberProfileDetailComReqDto();
  if(queryAppDetailComRespDto!=null){
      queryMemberProfileDetailComReqDto.setOriginalRoleMemberId(queryAppDetailComRespDto.getSenderMemberId());//SimpleFieldAssign//sourceId:1403853_1_56398
queryMemberProfileDetailComReqDto.setSpaceId(queryAppDetailComRespDto.getUniqueSpaceId());//SimpleFieldAssign//sourceId:1403854_1_56398
    }

    /*D1查询小助手个人账号及头像姓名[6778]   */
    Assert.isNull(queryMemberProfileDetailComReqDto.getOriginalRoleMemberId(),"D3执行想问答(公共)-D1查询小助手个人账号及头像姓名-身份人员ID不能为空",false);
Assert.isNull(queryMemberProfileDetailComReqDto.getSpaceId(),"D3执行想问答(公共)-D1查询小助手个人账号及头像姓名-创建于空间ID不能为空",false);
      queryMemberProfileDetailComRespDto = fwBaseMemberClient.queryMemberProfileDetailCom(queryMemberProfileDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
QueryMeMessageVirtualImageDetailComRespDto queryMeMessageVirtualImageDetailComRespDto = null;
    if(queryMemberProfileDetailComRespDto !=null){
          QueryMeMessageVirtualImageDetailComReqDto queryMeMessageVirtualImageDetailComReqDto=new QueryMeMessageVirtualImageDetailComReqDto();
  queryMeMessageVirtualImageDetailComReqDto.setVirtualImageViewType("SELF_COGNITION");//sourceId:1479335_1_59233
  queryMeMessageVirtualImageDetailComReqDto.setSceneTypeCode("SYSTEM");//sourceId:1478637_1_59233
queryMeMessageVirtualImageDetailComReqDto.setSceneSubTypeCode("STRONG_REMINDER_BY_ASSISTANT");//sourceId:1478643_1_59233
if(queryMemberProfileDetailComRespDto!=null){
      queryMeMessageVirtualImageDetailComReqDto.setOriginalRoleMemberId(queryMemberProfileDetailComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1478636_1_59233
    }
if(reqDto!=null){
      queryMeMessageVirtualImageDetailComReqDto.setResultAspObjId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1478648_1_59233
    }

    /*D2查询我的消息提醒形象详情(公共)[6800]   */
    Assert.isNull(queryMeMessageVirtualImageDetailComReqDto.getOriginalRoleMemberId(),"D3执行想问答(公共)-D2查询我的消息提醒形象详情(公共)-身份人员ID不能为空",false);
Assert.isNull(queryMeMessageVirtualImageDetailComReqDto.getVirtualImageViewType(),"D3执行想问答(公共)-D2查询我的消息提醒形象详情(公共)-虚拟形象展示用途类型不能为空",false);
Assert.isNull(queryMeMessageVirtualImageDetailComReqDto.getSceneTypeCode(),"D3执行想问答(公共)-D2查询我的消息提醒形象详情(公共)-冗余使用大场景类型编码不能为空",false);
Assert.isNull(queryMeMessageVirtualImageDetailComReqDto.getSceneSubTypeCode(),"D3执行想问答(公共)-D2查询我的消息提醒形象详情(公共)-冗余使用子场景类型编码不能为空",false);
Assert.isNull(queryMeMessageVirtualImageDetailComReqDto.getResultAspObjId(),"D3执行想问答(公共)-D2查询我的消息提醒形象详情(公共)-开通对象ID不能为空",false);
      queryMeMessageVirtualImageDetailComRespDto = fwCompMessageClient.queryMeMessageVirtualImageDetailCom(queryMeMessageVirtualImageDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
QueryChannelDetailComRespDto queryChannelDetailComRespDto = null;
    QueryChannelDetailComReqDto queryChannelDetailComReqDto=new QueryChannelDetailComReqDto();
  if(reqDto!=null){
      queryChannelDetailComReqDto.setChannelTypeCode(reqDto.getChannelTypeCode());//SimpleFieldAssign//sourceId:1403681_1_56404
queryChannelDetailComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1403682_1_56404
queryChannelDetailComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1403691_1_56404
queryChannelDetailComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1403683_1_56404
    }

    /*D2查询通道详情(公共)[7101]   */
    Assert.isNull(queryChannelDetailComReqDto.getChannelTypeCode(),"D3执行想问答(公共)-D2查询通道详情(公共)-通道类型编码不能为空",false);
Assert.isNull(queryChannelDetailComReqDto.getEntityId(),"D3执行想问答(公共)-D2查询通道详情(公共)-归属主体内容ID不能为空",false);
Assert.isNull(queryChannelDetailComReqDto.getTableTypeCode(),"D3执行想问答(公共)-D2查询通道详情(公共)-归属主体内容类型编码不能为空",false);
Assert.isNull(queryChannelDetailComReqDto.getSpaceId(),"D3执行想问答(公共)-D2查询通道详情(公共)-创建于空间ID不能为空",false);
      queryChannelDetailComRespDto = fwCompMessageClient.queryChannelDetailCom(queryChannelDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((queryChannelDetailComRespDto!= null&& queryChannelDetailComRespDto.getMessageChannelId() == null )) {
        //if(D2查询通道详情(公共).通道ID 值等于空 )  56405

GenerateSemanticInstanceStoryComRespDto generateSemanticInstanceStoryComRespDto = null;
    if(queryUserInfoDetailComRespDto !=null){
          GenerateSemanticInstanceStoryComReqDto generateSemanticInstanceStoryComReqDto=new GenerateSemanticInstanceStoryComReqDto();
  generateSemanticInstanceStoryComReqDto.setTemplateSemanticEngineCode("TWO_PEOPLE_CHAT_DEFAULT_PROMPT_MESSAGE");//CUSTOM_CONVENTION//sourceId:1492482_1_59870
generateSemanticInstanceStoryComReqDto.setFirstFieldName("idCardName");//CUSTOM_CONVENTION//sourceId:1492476_1_59870
if(queryUserInfoDetailComRespDto!=null){
      generateSemanticInstanceStoryComReqDto.setFirstFieldValue(queryUserInfoDetailComRespDto.getIdCardName());//SimpleFieldAssign//sourceId:1492477_1_59870
    }

    /*D2生成“我是**”[8234]   */
    Assert.isNull(generateSemanticInstanceStoryComReqDto.getTemplateSemanticEngineCode(),"D3执行想问答(公共)-D2生成“我是**”-模板引擎标识不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto.getFirstFieldName(),"D3执行想问答(公共)-D2生成“我是**”-第一个字段字段名不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto.getFirstFieldValue(),"D3执行想问答(公共)-D2生成“我是**”-第一个字段字段值不能为空",false);
      generateSemanticInstanceStoryComRespDto = fwCompTemplateEngineClient.generateSemanticInstanceStoryCom(generateSemanticInstanceStoryComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
ImplementMulitDataToOneDatasComRespDto implementMulitDataToOneDatasComRespDto = null;
    if(queryMemberProfileDetailComRespDto !=null){
          ImplementMulitDataToOneDatasComReqDto implementMulitDataToOneDatasComReqDto=new ImplementMulitDataToOneDatasComReqDto();
  if(queryMemberProfileDetailComRespDto!=null){
      implementMulitDataToOneDatasComReqDto.setCustomField(queryMemberProfileDetailComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1492466_1_59869
implementMulitDataToOneDatasComReqDto.setCustomField1(queryMemberProfileDetailComRespDto.getUserId());//SimpleFieldAssign//sourceId:1492467_1_59869
    }

    /*D2小助手身份人员ID转数据集(公共)[5869]   */
    Assert.isNull(implementMulitDataToOneDatasComReqDto.getCustomField(),"D3执行想问答(公共)-D2小助手身份人员ID转数据集(公共)-第一条记录A字段不能为空",false);
Assert.isNull(implementMulitDataToOneDatasComReqDto.getCustomField1(),"D3执行想问答(公共)-D2小助手身份人员ID转数据集(公共)-第一条记录B字段不能为空",false);
      implementMulitDataToOneDatasComRespDto = fwCompInterfaceModeClient.implementMulitDataToOneDatasCom(implementMulitDataToOneDatasComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
ImplementPullNPeopleBuildGroupComRespDto implementPullNPeopleBuildGroupComRespDto = null;
    if(implementMulitDataToOneDatasComRespDto !=null&&generateSemanticInstanceStoryComRespDto !=null&&queryMemberProfileDetailComRespDto !=null&&queryUserInfoDetailComRespDto !=null){
          ImplementPullNPeopleBuildGroupComReqDto implementPullNPeopleBuildGroupComReqDto=new ImplementPullNPeopleBuildGroupComReqDto();
  implementPullNPeopleBuildGroupComReqDto.setMessageLocationTypeCode("INTELLIGENT_STUDY");//CUSTOM_CONVENTION//sourceId:1492437_1_59868
implementPullNPeopleBuildGroupComReqDto.setMessageTemplateCode("CREATE_MULT_GROUP_DEFAULT_PROMPT_MESSAGE");//CUSTOM_CONVENTION//sourceId:1492438_1_59868
implementPullNPeopleBuildGroupComReqDto.setPlatformReplace("FALSE");//sourceId:1492447_1_59868
implementPullNPeopleBuildGroupComReqDto.setChannelName("我的智能问答");//CUSTOM_CONVENTION//sourceId:1492450_1_59868
implementPullNPeopleBuildGroupComReqDto.setMessageImportantLevel(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:1492445_1_59868
implementPullNPeopleBuildGroupComReqDto.setBorcScene("TOB_SCENE");//sourceId:1492436_1_59868
implementPullNPeopleBuildGroupComReqDto.setIsAssistant("FALSE");//sourceId:1492439_1_59868
implementPullNPeopleBuildGroupComReqDto.setMessageRole("user");//sourceId:1492440_1_59868
implementPullNPeopleBuildGroupComReqDto.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1492458_1_59868
if(implementMulitDataToOneDatasComRespDto!= null&&  implementMulitDataToOneDatasComRespDto.getMulitDataToOneDatasList() !=null&& !CollectionUtil.isEmpty(implementMulitDataToOneDatasComRespDto.getMulitDataToOneDatasList())){
      implementPullNPeopleBuildGroupComReqDto.setMemberChannelList(//objList-to-objLists
        implementMulitDataToOneDatasComRespDto.getMulitDataToOneDatasList().stream().map(item -> {
            com.wicket.okrcomponent.integration.dto.MemberChannelDto elm = new com.wicket.okrcomponent.integration.dto.MemberChannelDto();
      if(item!=null){
      elm.setOriginalRoleMemberId(item.getCustomField1());//SimpleFieldAssign//sourceId:293902_2_59868
elm.setUserId(item.getCustomField2());//SimpleFieldAssign//sourceId:293903_2_59868
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1492435_1_59868
    }
if(reqDto!=null){
      implementPullNPeopleBuildGroupComReqDto.setMsgChannelClassCode(reqDto.getMsgChannelClassCode());//SimpleFieldAssign//sourceId:1492465_1_59868
implementPullNPeopleBuildGroupComReqDto.setChannelTypeCode(reqDto.getChannelTypeCode());//SimpleFieldAssign//sourceId:1492457_1_59868
implementPullNPeopleBuildGroupComReqDto.setNewTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1492451_1_59868
implementPullNPeopleBuildGroupComReqDto.setNewEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1492452_1_59868
implementPullNPeopleBuildGroupComReqDto.setSenderOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1492441_1_59868
implementPullNPeopleBuildGroupComReqDto.setSenderUserId(reqDto.getUserId());//SimpleFieldAssign//sourceId:1492442_1_59868
implementPullNPeopleBuildGroupComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1492448_1_59868
implementPullNPeopleBuildGroupComReqDto.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:1492449_1_59868
    }
if(generateSemanticInstanceStoryComRespDto!=null){
      implementPullNPeopleBuildGroupComReqDto.setMessageContent(generateSemanticInstanceStoryComRespDto.getObjectName());//SimpleFieldAssign//sourceId:1492446_1_59868
    }
if(queryMemberProfileDetailComRespDto!=null){
      implementPullNPeopleBuildGroupComReqDto.setChannelLogo(queryMemberProfileDetailComRespDto.getUserFace());//SimpleFieldAssign//sourceId:1492453_1_59868
    }
if(queryUserInfoDetailComRespDto!=null){
      implementPullNPeopleBuildGroupComReqDto.setSenderProfilePictureAddress(queryUserInfoDetailComRespDto.getUserFace());//SimpleFieldAssign//sourceId:1492443_1_59868
implementPullNPeopleBuildGroupComReqDto.setNameOfSender(queryUserInfoDetailComRespDto.getIdCardName());//SimpleFieldAssign//sourceId:1492444_1_59868
    }

    /*D2执行拉N人建群(公共)[7031]   */
    Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getMessageLocationTypeCode(),"D3执行想问答(公共)-D2执行拉N人建群(公共)-消息位置标识不能为空",false);
Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getMessageTemplateCode(),"D3执行想问答(公共)-D2执行拉N人建群(公共)-消息模板标识不能为空",false);
Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getPlatformReplace(),"D3执行想问答(公共)-D2执行拉N人建群(公共)-是否平台代操作不能为空",false);
Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getMsgChannelClassCode(),"D3执行想问答(公共)-D2执行拉N人建群(公共)-消息使用通道类别不能为空",false);
Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getChannelTypeCode(),"D3执行想问答(公共)-D2执行拉N人建群(公共)-通道类型编码不能为空",false);
Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getMessageContent(),"D3执行想问答(公共)-D2执行拉N人建群(公共)-消息内容不能为空",false);
Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getChannelName(),"D3执行想问答(公共)-D2执行拉N人建群(公共)-通道名称不能为空",false);
Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getChannelLogo(),"D3执行想问答(公共)-D2执行拉N人建群(公共)-通道缩略图地址不能为空",false);
Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getNewTableTypeCode(),"D3执行想问答(公共)-D2执行拉N人建群(公共)-通道归属主体内容类型编码不能为空",false);
Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getNewEntityId(),"D3执行想问答(公共)-D2执行拉N人建群(公共)-通道归属主体内容ID不能为空",false);
Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getMessageImportantLevel(),"D3执行想问答(公共)-D2执行拉N人建群(公共)-消息重要紧急度层级不能为空",false);
Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getBorcScene(),"D3执行想问答(公共)-D2执行拉N人建群(公共)-toB或toC场景不能为空",false);
Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getIsAssistant(),"D3执行想问答(公共)-D2执行拉N人建群(公共)-发送方是否助手不能为空",false);
Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getMessageRole(),"D3执行想问答(公共)-D2执行拉N人建群(公共)-发送方角色不能为空",false);
Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getSenderOriginalRoleMemberId(),"D3执行想问答(公共)-D2执行拉N人建群(公共)-发送方身份人员ID不能为空",false);
Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getSenderUserId(),"D3执行想问答(公共)-D2执行拉N人建群(公共)-发送方账号ID不能为空",false);
Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getSenderProfilePictureAddress(),"D3执行想问答(公共)-D2执行拉N人建群(公共)-发送方头像地址不能为空",false);
Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getNameOfSender(),"D3执行想问答(公共)-D2执行拉N人建群(公共)-发送方姓名不能为空",false);
Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getOperateTime(),"D3执行想问答(公共)-D2执行拉N人建群(公共)-操作时间不能为空",false);
Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getSpaceId(),"D3执行想问答(公共)-D2执行拉N人建群(公共)-创建于空间ID不能为空",false);
Assert.isNull(implementPullNPeopleBuildGroupComReqDto.getAppId(),"D3执行想问答(公共)-D2执行拉N人建群(公共)-创建于联盟应用ID不能为空",false);
      implementPullNPeopleBuildGroupComRespDto = fwCompMessageClient.implementPullNPeopleBuildGroupCom(implementPullNPeopleBuildGroupComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
ImplementGroupSendMessagesNpeopleComRespDto implementGroupSendMessagesNpeopleComRespDto = null;
    if(queryUserInfoDetailComRespDto !=null&&implementPullNPeopleBuildGroupComRespDto !=null){
          ImplementGroupSendMessagesNpeopleComReqDto implementGroupSendMessagesNpeopleComReqDto=new ImplementGroupSendMessagesNpeopleComReqDto();
  implementGroupSendMessagesNpeopleComReqDto.setBorcScene("TOB_SCENE");//sourceId:1403748_1_56407
implementGroupSendMessagesNpeopleComReqDto.setMessageLocationTypeCode("INTELLIGENT_STUDY");//CUSTOM_CONVENTION//sourceId:1403749_1_56407
implementGroupSendMessagesNpeopleComReqDto.setMessageTemplateCode("THIRD_QA_SESSION_MESSAGE_TEMPLATE");//CUSTOM_CONVENTION//sourceId:1403757_1_56407
implementGroupSendMessagesNpeopleComReqDto.setIsAssistant("FALSE");//sourceId:1403766_1_56407
implementGroupSendMessagesNpeopleComReqDto.setMessageRole("user");//sourceId:1403750_1_56407
implementGroupSendMessagesNpeopleComReqDto.setMessageImportantLevel(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:1403763_1_56407
implementGroupSendMessagesNpeopleComReqDto.setMessageTitle("我的问题");//CUSTOM_CONVENTION//sourceId:1403907_1_56407
implementGroupSendMessagesNpeopleComReqDto.setHandleType("NO_NEED_HANDLING");//sourceId:1443708_1_56407
implementGroupSendMessagesNpeopleComReqDto.setPlatformReplace("FALSE");//sourceId:1403760_1_56407
implementGroupSendMessagesNpeopleComReqDto.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1403771_1_56407
implementGroupSendMessagesNpeopleComReqDto.setComNumField(Long.valueOf(2));//CUSTOM_CONVENTION//sourceId:1403765_1_56407
if(reqDto!=null){
      implementGroupSendMessagesNpeopleComReqDto.setSenderOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1403906_1_56407
implementGroupSendMessagesNpeopleComReqDto.setSenderUserId(reqDto.getUserId());//SimpleFieldAssign//sourceId:1403752_1_56407
implementGroupSendMessagesNpeopleComReqDto.setSurfaceCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1403755_1_56407
implementGroupSendMessagesNpeopleComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1403756_1_56407
implementGroupSendMessagesNpeopleComReqDto.setMessageContent(reqDto.getContent());//SimpleFieldAssign//sourceId:1403764_1_56407
implementGroupSendMessagesNpeopleComReqDto.setMsgChannelClassCode(reqDto.getMsgChannelClassCode());//SimpleFieldAssign//sourceId:1447844_1_56407
implementGroupSendMessagesNpeopleComReqDto.setChannelTypeCode(reqDto.getChannelTypeCode());//SimpleFieldAssign//sourceId:1403770_1_56407
implementGroupSendMessagesNpeopleComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1403761_1_56407
implementGroupSendMessagesNpeopleComReqDto.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:1403762_1_56407
    }
if(queryUserInfoDetailComRespDto!=null){
      implementGroupSendMessagesNpeopleComReqDto.setSenderProfilePictureAddress(queryUserInfoDetailComRespDto.getUserFace());//SimpleFieldAssign//sourceId:1403753_1_56407
implementGroupSendMessagesNpeopleComReqDto.setNameOfSender(queryUserInfoDetailComRespDto.getIdCardName());//SimpleFieldAssign//sourceId:1403754_1_56407
    }
if(implementPullNPeopleBuildGroupComRespDto!=null){
      implementGroupSendMessagesNpeopleComReqDto.setMessageChannelId(implementPullNPeopleBuildGroupComRespDto.getMessageChannelId());//SimpleFieldAssign//sourceId:1403758_1_56407
implementGroupSendMessagesNpeopleComReqDto.setMemberChannelRelationId(implementPullNPeopleBuildGroupComRespDto.getMemberChannelRelationId());//SimpleFieldAssign//sourceId:1443709_1_56407
    }

    /*D2执行群里会话发消息N人(提问)[7028]   */
    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getBorcScene(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-toB或toC场景不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getMessageLocationTypeCode(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息位置标识不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getMessageTemplateCode(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息模板标识不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getIsAssistant(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方是否助手不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getMessageRole(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方角色不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getSenderOriginalRoleMemberId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方身份人员ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getSenderUserId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方账号ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getSenderProfilePictureAddress(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方头像地址不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getNameOfSender(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方姓名不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getSurfaceCode(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-归属内容类型编码不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getEntityId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-归属内容ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getMessageImportantLevel(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息重要紧急度层级不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getMessageTitle(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息标题不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getMessageContent(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息内容不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getMsgChannelClassCode(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息使用通道类别不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getChannelTypeCode(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-通道类型编码不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getMessageChannelId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息通道ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getMemberChannelRelationId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-成员通道关系ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getHandleType(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-处理类型不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getPlatformReplace(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-是否平台代操作不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getOperateTime(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-操作时间不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getSpaceId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-创建于空间ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getAppId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-创建于联盟应用ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto.getComNumField(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-通用数值字段（整数型）不能为空",false);
      implementGroupSendMessagesNpeopleComRespDto = fwCompMessageClient.implementGroupSendMessagesNpeopleCom(implementGroupSendMessagesNpeopleComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      Assert.isTrue(implementGroupSendMessagesNpeopleComRespDto== null||  implementGroupSendMessagesNpeopleComRespDto.getMessageId() ==null,"找不到数据，系统异常",false);


           }
QueryPushThirdPartyMessagesListComRespDto queryPushThirdPartyMessagesListComRespDto = null;
    if(implementPullNPeopleBuildGroupComRespDto !=null){
          QueryPushThirdPartyMessagesListComReqDto queryPushThirdPartyMessagesListComReqDto=new QueryPushThirdPartyMessagesListComReqDto();
  if(implementPullNPeopleBuildGroupComRespDto!=null){
      queryPushThirdPartyMessagesListComReqDto.setMessageChannelId(implementPullNPeopleBuildGroupComRespDto.getMessageChannelId());//SimpleFieldAssign//sourceId:1403938_1_56408
    }
if(reqDto!=null){
      queryPushThirdPartyMessagesListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1403941_1_56408
    }

    /*D2查询推第三方问题列表(公共)[8126]   */
    Assert.isNull(queryPushThirdPartyMessagesListComReqDto.getMessageChannelId(),"D3执行想问答(公共)-D2查询推第三方问题列表(公共)-消息通道ID不能为空",false);
Assert.isNull(queryPushThirdPartyMessagesListComReqDto.getSpaceId(),"D3执行想问答(公共)-D2查询推第三方问题列表(公共)-创建于空间ID不能为空",false);
      queryPushThirdPartyMessagesListComRespDto = fwCompMessageClient.queryPushThirdPartyMessagesListCom(queryPushThirdPartyMessagesListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
ImplementGuidedThirdPartyIntelligentQaComRespDto implementGuidedThirdPartyIntelligentQaComRespDto = null;
    if(queryPushThirdPartyMessagesListComRespDto !=null){
          ImplementGuidedThirdPartyIntelligentQaComReqDto implementGuidedThirdPartyIntelligentQaComReqDto=new ImplementGuidedThirdPartyIntelligentQaComReqDto();
  implementGuidedThirdPartyIntelligentQaComReqDto.setBusModelVersion("PLUS_VERSION");//sourceId:2036958_1_56409
  if(reqDto!=null){
      implementGuidedThirdPartyIntelligentQaComReqDto.setResultAspObjId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1403978_1_56409
    }
if(queryPushThirdPartyMessagesListComRespDto!= null&&  queryPushThirdPartyMessagesListComRespDto.getPushThirdPartyMessagesList() !=null&& !CollectionUtil.isEmpty(queryPushThirdPartyMessagesListComRespDto.getPushThirdPartyMessagesList())){
      implementGuidedThirdPartyIntelligentQaComReqDto.setGetListIntelligentAnswersList(//objList-to-objLists
        queryPushThirdPartyMessagesListComRespDto.getPushThirdPartyMessagesList().stream().map(item -> {
      GetListIntelligentAnswersDto elm = new GetListIntelligentAnswersDto();
      if(item!=null){
      elm.setContent(item.getMessageContent());//SimpleFieldAssign//sourceId:282658_2_56409
elm.setRole(item.getMessageRole());//SimpleFieldAssign//sourceId:282659_2_56409
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1403979_1_56409
    }

    /*D2执行导向第三方智能问答(公共)[8103]   */
    Assert.isNull(implementGuidedThirdPartyIntelligentQaComReqDto.getResultAspObjId(),"D3执行想问答(公共)-D2执行导向第三方智能问答(公共)-开通对象ID不能为空",false);
Assert.isNull(implementGuidedThirdPartyIntelligentQaComReqDto.getBusModelVersion(),"D3执行想问答(公共)-D2执行导向第三方智能问答(公共)-业务模型版本不能为空",false);
      implementGuidedThirdPartyIntelligentQaComRespDto = fwCompIntelligentCommunicationClient.implementGuidedThirdPartyIntelligentQaCom(implementGuidedThirdPartyIntelligentQaComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      implementGuidedThirdPartyIntelligentQaComRespDto_1 = implementGuidedThirdPartyIntelligentQaComRespDto;
           }
QueryMemberChannelDetailComRespDto queryMemberChannelDetailComRespDto = null;
    if(implementPullNPeopleBuildGroupComRespDto !=null&&queryMemberProfileDetailComRespDto !=null){
          QueryMemberChannelDetailComReqDto queryMemberChannelDetailComReqDto=new QueryMemberChannelDetailComReqDto();
  queryMemberChannelDetailComReqDto.setBorcScene("TOB_SCENE");//sourceId:1403742_1_59875
if(implementPullNPeopleBuildGroupComRespDto!=null){
      queryMemberChannelDetailComReqDto.setChannelId(implementPullNPeopleBuildGroupComRespDto.getMessageChannelId());//SimpleFieldAssign//sourceId:1403741_1_59875
    }
if(queryMemberProfileDetailComRespDto!=null){
      queryMemberChannelDetailComReqDto.setOriginalRoleMemberId(queryMemberProfileDetailComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1403743_1_59875
queryMemberChannelDetailComReqDto.setUserId(queryMemberProfileDetailComRespDto.getUserId());//SimpleFieldAssign//sourceId:1403744_1_59875
    }

    /*D2查询成员通道详情(公共)[7305]   */
    Assert.isNull(queryMemberChannelDetailComReqDto.getChannelId(),"D3执行想问答(公共)-D2查询成员通道详情(公共)-通道ID不能为空",false);
Assert.isNull(queryMemberChannelDetailComReqDto.getBorcScene(),"D3执行想问答(公共)-D2查询成员通道详情(公共)-toB或toC场景不能为空",false);
Assert.isNull(queryMemberChannelDetailComReqDto.getOriginalRoleMemberId(),"D3执行想问答(公共)-D2查询成员通道详情(公共)-归属身份人员ID不能为空",false);
Assert.isNull(queryMemberChannelDetailComReqDto.getUserId(),"D3执行想问答(公共)-D2查询成员通道详情(公共)-归属个人账号ID不能为空",false);
      queryMemberChannelDetailComRespDto = fwCompMessageClient.queryMemberChannelDetailCom(queryMemberChannelDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
ImplementGroupSendMessagesNpeopleComRespDto implementGroupSendMessagesNpeopleComRespDto_2 = null;
    if(queryMemberProfileDetailComRespDto !=null&&implementGuidedThirdPartyIntelligentQaComRespDto !=null&&implementPullNPeopleBuildGroupComRespDto !=null&&queryMemberChannelDetailComRespDto !=null){
          ImplementGroupSendMessagesNpeopleComReqDto implementGroupSendMessagesNpeopleComReqDto_1=new ImplementGroupSendMessagesNpeopleComReqDto();
  implementGroupSendMessagesNpeopleComReqDto_1.setBorcScene("TOB_SCENE");//sourceId:1403943_1_56410
implementGroupSendMessagesNpeopleComReqDto_1.setMessageLocationTypeCode("INTELLIGENT_STUDY");//CUSTOM_CONVENTION//sourceId:1403944_1_56410
implementGroupSendMessagesNpeopleComReqDto_1.setMessageTemplateCode("Q_AND_A_MESSAGE_TEMPLATE");//CUSTOM_CONVENTION//sourceId:1403952_1_56410
implementGroupSendMessagesNpeopleComReqDto_1.setIsAssistant("TRUE");//sourceId:1403961_1_56410
implementGroupSendMessagesNpeopleComReqDto_1.setMessageRole("system");//sourceId:1403945_1_56410
implementGroupSendMessagesNpeopleComReqDto_1.setMessageImportantLevel(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:1403958_1_56410
implementGroupSendMessagesNpeopleComReqDto_1.setMessageTitle("问题回答");//CUSTOM_CONVENTION//sourceId:1403967_1_56410
implementGroupSendMessagesNpeopleComReqDto_1.setHandleType("NO_NEED_HANDLING");//sourceId:1443706_1_56410
implementGroupSendMessagesNpeopleComReqDto_1.setPlatformReplace("FALSE");//sourceId:1403955_1_56410
implementGroupSendMessagesNpeopleComReqDto_1.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1403966_1_56410
implementGroupSendMessagesNpeopleComReqDto_1.setComNumField(Long.valueOf(2));//CUSTOM_CONVENTION//sourceId:1403960_1_56410
if(queryMemberProfileDetailComRespDto!=null){
      implementGroupSendMessagesNpeopleComReqDto_1.setSenderOriginalRoleMemberId(queryMemberProfileDetailComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1403946_1_56410
implementGroupSendMessagesNpeopleComReqDto_1.setSenderUserId(queryMemberProfileDetailComRespDto.getUserId());//SimpleFieldAssign//sourceId:1403947_1_56410
implementGroupSendMessagesNpeopleComReqDto_1.setSenderProfilePictureAddress(queryMemberProfileDetailComRespDto.getUserFace());//SimpleFieldAssign//sourceId:1403948_1_56410
implementGroupSendMessagesNpeopleComReqDto_1.setNameOfSender(queryMemberProfileDetailComRespDto.getIdCardName());//SimpleFieldAssign//sourceId:1403949_1_56410
    }
if(reqDto!=null){
      implementGroupSendMessagesNpeopleComReqDto_1.setSurfaceCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1403950_1_56410
implementGroupSendMessagesNpeopleComReqDto_1.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1403951_1_56410
implementGroupSendMessagesNpeopleComReqDto_1.setMsgChannelClassCode(reqDto.getMsgChannelClassCode());//SimpleFieldAssign//sourceId:1447843_1_56410
implementGroupSendMessagesNpeopleComReqDto_1.setChannelTypeCode(reqDto.getChannelTypeCode());//SimpleFieldAssign//sourceId:1403965_1_56410
implementGroupSendMessagesNpeopleComReqDto_1.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1403956_1_56410
implementGroupSendMessagesNpeopleComReqDto_1.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:1403957_1_56410
    }
if(implementGuidedThirdPartyIntelligentQaComRespDto!=null){
      implementGroupSendMessagesNpeopleComReqDto_1.setMessageContent(implementGuidedThirdPartyIntelligentQaComRespDto.getContent());//SimpleFieldAssign//sourceId:1403959_1_56410
    }
if(implementPullNPeopleBuildGroupComRespDto!=null){
      implementGroupSendMessagesNpeopleComReqDto_1.setMessageChannelId(implementPullNPeopleBuildGroupComRespDto.getMessageChannelId());//SimpleFieldAssign//sourceId:1403953_1_56410
    }
if(queryMemberChannelDetailComRespDto!=null){
      implementGroupSendMessagesNpeopleComReqDto_1.setMemberChannelRelationId(queryMemberChannelDetailComRespDto.getMemberChannelRelationId());//SimpleFieldAssign//sourceId:1443707_1_56410
    }

    /*D2执行群里会话发消息N人(第三方回答)[7028]   */
    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getBorcScene(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-toB或toC场景不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getMessageLocationTypeCode(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息位置标识不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getMessageTemplateCode(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息模板标识不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getIsAssistant(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方是否助手不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getMessageRole(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方角色不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getSenderOriginalRoleMemberId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方身份人员ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getSenderUserId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方账号ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getSenderProfilePictureAddress(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方头像地址不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getNameOfSender(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方姓名不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getSurfaceCode(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-归属内容类型编码不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getEntityId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-归属内容ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getMessageImportantLevel(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息重要紧急度层级不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getMessageTitle(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息标题不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getMessageContent(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息内容不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getHandleType(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-处理类型不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getMsgChannelClassCode(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息使用通道类别不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getChannelTypeCode(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-通道类型编码不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getMessageChannelId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息通道ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getMemberChannelRelationId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-成员通道关系ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getPlatformReplace(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-是否平台代操作不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getOperateTime(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-操作时间不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getSpaceId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-创建于空间ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getAppId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-创建于联盟应用ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_1.getComNumField(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-通用数值字段（整数型）不能为空",false);
      implementGroupSendMessagesNpeopleComRespDto_2 = fwCompMessageClient.implementGroupSendMessagesNpeopleCom(implementGroupSendMessagesNpeopleComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



           }
      }
else if((queryChannelDetailComRespDto!= null&& queryChannelDetailComRespDto.getMessageChannelId() != null )){
       //elseif(D2查询通道详情(公共).通道ID 值不等于空 )  56411

QueryMemberChannelDetailComRespDto queryMemberChannelDetailComRespDto_2 = null;
    if(queryChannelDetailComRespDto !=null){
          QueryMemberChannelDetailComReqDto queryMemberChannelDetailComReqDto_1=new QueryMemberChannelDetailComReqDto();
  queryMemberChannelDetailComReqDto_1.setBorcScene("TOB_SCENE");//sourceId:1403742_1_56412
if(queryChannelDetailComRespDto!=null){
      queryMemberChannelDetailComReqDto_1.setChannelId(queryChannelDetailComRespDto.getMessageChannelId());//SimpleFieldAssign//sourceId:1403741_1_56412
    }
if(reqDto!=null){
      queryMemberChannelDetailComReqDto_1.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1403743_1_56412
queryMemberChannelDetailComReqDto_1.setUserId(reqDto.getUserId());//SimpleFieldAssign//sourceId:1403744_1_56412
    }

    /*D2查询成员通道详情(公共)[7305]   */
    Assert.isNull(queryMemberChannelDetailComReqDto_1.getChannelId(),"D3执行想问答(公共)-D2查询成员通道详情(公共)-通道ID不能为空",false);
Assert.isNull(queryMemberChannelDetailComReqDto_1.getBorcScene(),"D3执行想问答(公共)-D2查询成员通道详情(公共)-toB或toC场景不能为空",false);
Assert.isNull(queryMemberChannelDetailComReqDto_1.getOriginalRoleMemberId(),"D3执行想问答(公共)-D2查询成员通道详情(公共)-归属身份人员ID不能为空",false);
Assert.isNull(queryMemberChannelDetailComReqDto_1.getUserId(),"D3执行想问答(公共)-D2查询成员通道详情(公共)-归属个人账号ID不能为空",false);
      queryMemberChannelDetailComRespDto_2 = fwCompMessageClient.queryMemberChannelDetailCom(queryMemberChannelDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((queryMemberChannelDetailComRespDto_2!= null&& queryMemberChannelDetailComRespDto_2.getMemberChannelRelationId() != null )) {
        //if(D2查询提问身份人员成员通道详情(用于强提醒消息降级).成员通道关系ID 值不等于空 )  56413

ImplementGroupSendMessagesNpeopleComRespDto implementGroupSendMessagesNpeopleComRespDto_4 = null;
    if(queryUserInfoDetailComRespDto !=null&&queryChannelDetailComRespDto !=null&&queryMemberChannelDetailComRespDto_2 !=null){
          ImplementGroupSendMessagesNpeopleComReqDto implementGroupSendMessagesNpeopleComReqDto_2=new ImplementGroupSendMessagesNpeopleComReqDto();
  implementGroupSendMessagesNpeopleComReqDto_2.setBorcScene("TOB_SCENE");//sourceId:1403748_1_56415
implementGroupSendMessagesNpeopleComReqDto_2.setMessageLocationTypeCode("INTELLIGENT_STUDY");//CUSTOM_CONVENTION//sourceId:1403749_1_56415
implementGroupSendMessagesNpeopleComReqDto_2.setMessageTemplateCode("THIRD_QA_SESSION_MESSAGE_TEMPLATE");//CUSTOM_CONVENTION//sourceId:1403757_1_56415
implementGroupSendMessagesNpeopleComReqDto_2.setIsAssistant("FALSE");//sourceId:1403766_1_56415
implementGroupSendMessagesNpeopleComReqDto_2.setMessageRole("user");//sourceId:1403750_1_56415
implementGroupSendMessagesNpeopleComReqDto_2.setMessageImportantLevel(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:1403763_1_56415
implementGroupSendMessagesNpeopleComReqDto_2.setMessageTitle("我的问题");//CUSTOM_CONVENTION//sourceId:1403907_1_56415
implementGroupSendMessagesNpeopleComReqDto_2.setHandleType("NO_NEED_HANDLING");//sourceId:1443708_1_56415
implementGroupSendMessagesNpeopleComReqDto_2.setPlatformReplace("FALSE");//sourceId:1403760_1_56415
implementGroupSendMessagesNpeopleComReqDto_2.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1403771_1_56415
implementGroupSendMessagesNpeopleComReqDto_2.setComNumField(Long.valueOf(2));//CUSTOM_CONVENTION//sourceId:1403765_1_56415
if(reqDto!=null){
      implementGroupSendMessagesNpeopleComReqDto_2.setSenderOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1403906_1_56415
implementGroupSendMessagesNpeopleComReqDto_2.setSenderUserId(reqDto.getUserId());//SimpleFieldAssign//sourceId:1403752_1_56415
implementGroupSendMessagesNpeopleComReqDto_2.setMessageContent(reqDto.getContent());//SimpleFieldAssign//sourceId:1403764_1_56415
implementGroupSendMessagesNpeopleComReqDto_2.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1403761_1_56415
implementGroupSendMessagesNpeopleComReqDto_2.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:1403762_1_56415
    }
if(queryUserInfoDetailComRespDto!=null){
      implementGroupSendMessagesNpeopleComReqDto_2.setSenderProfilePictureAddress(queryUserInfoDetailComRespDto.getUserFace());//SimpleFieldAssign//sourceId:1403753_1_56415
implementGroupSendMessagesNpeopleComReqDto_2.setNameOfSender(queryUserInfoDetailComRespDto.getIdCardName());//SimpleFieldAssign//sourceId:1403754_1_56415
    }
if(queryChannelDetailComRespDto!=null){
      implementGroupSendMessagesNpeopleComReqDto_2.setSurfaceCode(queryChannelDetailComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1403755_1_56415
implementGroupSendMessagesNpeopleComReqDto_2.setEntityId(queryChannelDetailComRespDto.getEntityId());//SimpleFieldAssign//sourceId:1403756_1_56415
implementGroupSendMessagesNpeopleComReqDto_2.setMsgChannelClassCode(queryChannelDetailComRespDto.getMsgChannelClassCode());//SimpleFieldAssign//sourceId:1447844_1_56415
implementGroupSendMessagesNpeopleComReqDto_2.setChannelTypeCode(queryChannelDetailComRespDto.getChannelTypeCode());//SimpleFieldAssign//sourceId:1403770_1_56415
implementGroupSendMessagesNpeopleComReqDto_2.setMessageChannelId(queryChannelDetailComRespDto.getMessageChannelId());//SimpleFieldAssign//sourceId:1403758_1_56415
    }
if(queryMemberChannelDetailComRespDto_2!=null){
      implementGroupSendMessagesNpeopleComReqDto_2.setMemberChannelRelationId(queryMemberChannelDetailComRespDto_2.getMemberChannelRelationId());//SimpleFieldAssign//sourceId:1443709_1_56415
    }

    /*D2执行群里会话发消息N人(提问)[7028]   */
    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getBorcScene(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-toB或toC场景不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getMessageLocationTypeCode(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息位置标识不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getMessageTemplateCode(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息模板标识不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getIsAssistant(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方是否助手不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getMessageRole(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方角色不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getSenderOriginalRoleMemberId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方身份人员ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getSenderUserId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方账号ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getSenderProfilePictureAddress(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方头像地址不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getNameOfSender(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方姓名不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getSurfaceCode(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-归属内容类型编码不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getEntityId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-归属内容ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getMessageImportantLevel(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息重要紧急度层级不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getMessageTitle(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息标题不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getMessageContent(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息内容不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getMsgChannelClassCode(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息使用通道类别不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getChannelTypeCode(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-通道类型编码不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getMessageChannelId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息通道ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getMemberChannelRelationId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-成员通道关系ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getHandleType(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-处理类型不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getPlatformReplace(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-是否平台代操作不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getOperateTime(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-操作时间不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getSpaceId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-创建于空间ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getAppId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-创建于联盟应用ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_2.getComNumField(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-通用数值字段（整数型）不能为空",false);
      implementGroupSendMessagesNpeopleComRespDto_4 = fwCompMessageClient.implementGroupSendMessagesNpeopleCom(implementGroupSendMessagesNpeopleComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;
      Assert.isTrue(implementGroupSendMessagesNpeopleComRespDto_4== null||  implementGroupSendMessagesNpeopleComRespDto_4.getMessageId() ==null,"找不到数据，系统异常",false);


           }
QueryPushThirdPartyMessagesListComRespDto queryPushThirdPartyMessagesListComRespDto_2 = null;
    if(queryChannelDetailComRespDto !=null){
          QueryPushThirdPartyMessagesListComReqDto queryPushThirdPartyMessagesListComReqDto_1=new QueryPushThirdPartyMessagesListComReqDto();
  if(queryChannelDetailComRespDto!=null){
      queryPushThirdPartyMessagesListComReqDto_1.setMessageChannelId(queryChannelDetailComRespDto.getMessageChannelId());//SimpleFieldAssign//sourceId:1403938_1_56418
    }
if(reqDto!=null){
      queryPushThirdPartyMessagesListComReqDto_1.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1403941_1_56418
    }

    /*D2查询推第三方问题列表(公共)[8126]   */
    Assert.isNull(queryPushThirdPartyMessagesListComReqDto_1.getMessageChannelId(),"D3执行想问答(公共)-D2查询推第三方问题列表(公共)-消息通道ID不能为空",false);
Assert.isNull(queryPushThirdPartyMessagesListComReqDto_1.getSpaceId(),"D3执行想问答(公共)-D2查询推第三方问题列表(公共)-创建于空间ID不能为空",false);
      queryPushThirdPartyMessagesListComRespDto_2 = fwCompMessageClient.queryPushThirdPartyMessagesListCom(queryPushThirdPartyMessagesListComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



           }
ImplementGuidedThirdPartyIntelligentQaComRespDto implementGuidedThirdPartyIntelligentQaComRespDto_2 = null;
    if(queryPushThirdPartyMessagesListComRespDto_2 !=null){
          ImplementGuidedThirdPartyIntelligentQaComReqDto implementGuidedThirdPartyIntelligentQaComReqDto_1=new ImplementGuidedThirdPartyIntelligentQaComReqDto();
  implementGuidedThirdPartyIntelligentQaComReqDto_1.setBusModelVersion("PLUS_VERSION");//sourceId:2036958_1_56419
  if(reqDto!=null){
      implementGuidedThirdPartyIntelligentQaComReqDto_1.setResultAspObjId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1403978_1_56419
    }
if(queryPushThirdPartyMessagesListComRespDto_2!= null&&  queryPushThirdPartyMessagesListComRespDto_2.getPushThirdPartyMessagesList() !=null&& !CollectionUtil.isEmpty(queryPushThirdPartyMessagesListComRespDto_2.getPushThirdPartyMessagesList())){
      implementGuidedThirdPartyIntelligentQaComReqDto_1.setGetListIntelligentAnswersList(//objList-to-objLists
        queryPushThirdPartyMessagesListComRespDto_2.getPushThirdPartyMessagesList().stream().map(item -> {
      GetListIntelligentAnswersDto elm = new GetListIntelligentAnswersDto();
      if(item!=null){
      elm.setContent(item.getMessageContent());//SimpleFieldAssign//sourceId:282658_2_56419
elm.setRole(item.getMessageRole());//SimpleFieldAssign//sourceId:282659_2_56419
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1403979_1_56419
    }

    /*D2执行导向第三方智能问答(公共)[8103]   */
    Assert.isNull(implementGuidedThirdPartyIntelligentQaComReqDto_1.getResultAspObjId(),"D3执行想问答(公共)-D2执行导向第三方智能问答(公共)-开通对象ID不能为空",false);
Assert.isNull(implementGuidedThirdPartyIntelligentQaComReqDto_1.getBusModelVersion(),"D3执行想问答(公共)-D2执行导向第三方智能问答(公共)-业务模型版本不能为空",false);
      implementGuidedThirdPartyIntelligentQaComRespDto_2 = fwCompIntelligentCommunicationClient.implementGuidedThirdPartyIntelligentQaCom(implementGuidedThirdPartyIntelligentQaComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


      implementGuidedThirdPartyIntelligentQaComRespDto_1 = implementGuidedThirdPartyIntelligentQaComRespDto_2;
           }
QueryMemberChannelDetailComRespDto queryMemberChannelDetailComRespDto_3 = null;
    if(queryChannelDetailComRespDto !=null&&queryMemberProfileDetailComRespDto !=null){
          QueryMemberChannelDetailComReqDto queryMemberChannelDetailComReqDto_2=new QueryMemberChannelDetailComReqDto();
  queryMemberChannelDetailComReqDto_2.setBorcScene("TOB_SCENE");//sourceId:1403742_1_59876
if(queryChannelDetailComRespDto!=null){
      queryMemberChannelDetailComReqDto_2.setChannelId(queryChannelDetailComRespDto.getMessageChannelId());//SimpleFieldAssign//sourceId:1403741_1_59876
    }
if(queryMemberProfileDetailComRespDto!=null){
      queryMemberChannelDetailComReqDto_2.setOriginalRoleMemberId(queryMemberProfileDetailComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1403743_1_59876
queryMemberChannelDetailComReqDto_2.setUserId(queryMemberProfileDetailComRespDto.getUserId());//SimpleFieldAssign//sourceId:1403744_1_59876
    }

    /*D2查询成员通道详情(公共)[7305]   */
    Assert.isNull(queryMemberChannelDetailComReqDto_2.getChannelId(),"D3执行想问答(公共)-D2查询成员通道详情(公共)-通道ID不能为空",false);
Assert.isNull(queryMemberChannelDetailComReqDto_2.getBorcScene(),"D3执行想问答(公共)-D2查询成员通道详情(公共)-toB或toC场景不能为空",false);
Assert.isNull(queryMemberChannelDetailComReqDto_2.getOriginalRoleMemberId(),"D3执行想问答(公共)-D2查询成员通道详情(公共)-归属身份人员ID不能为空",false);
Assert.isNull(queryMemberChannelDetailComReqDto_2.getUserId(),"D3执行想问答(公共)-D2查询成员通道详情(公共)-归属个人账号ID不能为空",false);
      queryMemberChannelDetailComRespDto_3 = fwCompMessageClient.queryMemberChannelDetailCom(queryMemberChannelDetailComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;



           }
ImplementGroupSendMessagesNpeopleComRespDto implementGroupSendMessagesNpeopleComRespDto_5 = null;
    if(queryMemberProfileDetailComRespDto !=null&&queryChannelDetailComRespDto !=null&&implementGuidedThirdPartyIntelligentQaComRespDto_2 !=null&&queryMemberChannelDetailComRespDto_3 !=null){
          ImplementGroupSendMessagesNpeopleComReqDto implementGroupSendMessagesNpeopleComReqDto_3=new ImplementGroupSendMessagesNpeopleComReqDto();
  implementGroupSendMessagesNpeopleComReqDto_3.setBorcScene("TOB_SCENE");//sourceId:1403943_1_56420
implementGroupSendMessagesNpeopleComReqDto_3.setMessageLocationTypeCode("INTELLIGENT_STUDY");//CUSTOM_CONVENTION//sourceId:1403944_1_56420
implementGroupSendMessagesNpeopleComReqDto_3.setMessageTemplateCode("Q_AND_A_MESSAGE_TEMPLATE");//CUSTOM_CONVENTION//sourceId:1403952_1_56420
implementGroupSendMessagesNpeopleComReqDto_3.setIsAssistant("TRUE");//sourceId:1403961_1_56420
implementGroupSendMessagesNpeopleComReqDto_3.setMessageRole("system");//sourceId:1403945_1_56420
implementGroupSendMessagesNpeopleComReqDto_3.setMessageImportantLevel(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:1403958_1_56420
implementGroupSendMessagesNpeopleComReqDto_3.setMessageTitle("问题回答");//CUSTOM_CONVENTION//sourceId:1403967_1_56420
implementGroupSendMessagesNpeopleComReqDto_3.setHandleType("NO_NEED_HANDLING");//sourceId:1443706_1_56420
implementGroupSendMessagesNpeopleComReqDto_3.setPlatformReplace("FALSE");//sourceId:1403955_1_56420
implementGroupSendMessagesNpeopleComReqDto_3.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1403966_1_56420
implementGroupSendMessagesNpeopleComReqDto_3.setComNumField(Long.valueOf(2));//CUSTOM_CONVENTION//sourceId:1403960_1_56420
if(queryMemberProfileDetailComRespDto!=null){
      implementGroupSendMessagesNpeopleComReqDto_3.setSenderOriginalRoleMemberId(queryMemberProfileDetailComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1403946_1_56420
implementGroupSendMessagesNpeopleComReqDto_3.setSenderUserId(queryMemberProfileDetailComRespDto.getUserId());//SimpleFieldAssign//sourceId:1403947_1_56420
implementGroupSendMessagesNpeopleComReqDto_3.setSenderProfilePictureAddress(queryMemberProfileDetailComRespDto.getUserFace());//SimpleFieldAssign//sourceId:1403948_1_56420
implementGroupSendMessagesNpeopleComReqDto_3.setNameOfSender(queryMemberProfileDetailComRespDto.getIdCardName());//SimpleFieldAssign//sourceId:1403949_1_56420
    }
if(queryChannelDetailComRespDto!=null){
      implementGroupSendMessagesNpeopleComReqDto_3.setSurfaceCode(queryChannelDetailComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1403950_1_56420
implementGroupSendMessagesNpeopleComReqDto_3.setEntityId(queryChannelDetailComRespDto.getEntityId());//SimpleFieldAssign//sourceId:1403951_1_56420
implementGroupSendMessagesNpeopleComReqDto_3.setMsgChannelClassCode(queryChannelDetailComRespDto.getMsgChannelClassCode());//SimpleFieldAssign//sourceId:1447843_1_56420
implementGroupSendMessagesNpeopleComReqDto_3.setChannelTypeCode(queryChannelDetailComRespDto.getChannelTypeCode());//SimpleFieldAssign//sourceId:1403965_1_56420
implementGroupSendMessagesNpeopleComReqDto_3.setMessageChannelId(queryChannelDetailComRespDto.getMessageChannelId());//SimpleFieldAssign//sourceId:1403953_1_56420
    }
if(implementGuidedThirdPartyIntelligentQaComRespDto_2!=null){
      implementGroupSendMessagesNpeopleComReqDto_3.setMessageContent(implementGuidedThirdPartyIntelligentQaComRespDto_2.getContent());//SimpleFieldAssign//sourceId:1403959_1_56420
    }
if(queryMemberChannelDetailComRespDto_3!=null){
      implementGroupSendMessagesNpeopleComReqDto_3.setMemberChannelRelationId(queryMemberChannelDetailComRespDto_3.getMemberChannelRelationId());//SimpleFieldAssign//sourceId:1443707_1_56420
    }
if(reqDto!=null){
      implementGroupSendMessagesNpeopleComReqDto_3.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1403956_1_56420
implementGroupSendMessagesNpeopleComReqDto_3.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:1403957_1_56420
    }

    /*D2执行群里会话发消息N人(第三方回答)[7028]   */
    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getBorcScene(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-toB或toC场景不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getMessageLocationTypeCode(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息位置标识不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getMessageTemplateCode(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息模板标识不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getIsAssistant(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方是否助手不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getMessageRole(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方角色不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getSenderOriginalRoleMemberId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方身份人员ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getSenderUserId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方账号ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getSenderProfilePictureAddress(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方头像地址不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getNameOfSender(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方姓名不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getSurfaceCode(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-归属内容类型编码不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getEntityId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-归属内容ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getMessageImportantLevel(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息重要紧急度层级不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getMessageTitle(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息标题不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getMessageContent(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息内容不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getHandleType(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-处理类型不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getMsgChannelClassCode(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息使用通道类别不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getChannelTypeCode(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-通道类型编码不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getMessageChannelId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息通道ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getMemberChannelRelationId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-成员通道关系ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getPlatformReplace(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-是否平台代操作不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getOperateTime(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-操作时间不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getSpaceId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-创建于空间ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getAppId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-创建于联盟应用ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_3.getComNumField(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-通用数值字段（整数型）不能为空",false);
      implementGroupSendMessagesNpeopleComRespDto_5 = fwCompMessageClient.implementGroupSendMessagesNpeopleCom(implementGroupSendMessagesNpeopleComReqDto_3).getData()/*vcase invoke 跨dubbo调用;*/;



           }
      }
else if((queryMemberChannelDetailComRespDto_2!= null&& queryMemberChannelDetailComRespDto_2.getMemberChannelRelationId() == null )){
       //elseif(D2查询提问身份人员成员通道详情(用于强提醒消息降级).成员通道关系ID 值等于空 )  56414

ImplementInitializationMemberChannelComRespDto implementInitializationMemberChannelComRespDto = null;
    if(queryChannelDetailComRespDto !=null&&queryMemberProfileDetailComRespDto !=null&&queryMeMessageVirtualImageDetailComRespDto !=null){
          ImplementInitializationMemberChannelComReqDto implementInitializationMemberChannelComReqDto=new ImplementInitializationMemberChannelComReqDto();
  implementInitializationMemberChannelComReqDto.setUseChannelMethod("ISHAVE_CHANNEL");//sourceId:1403721_1_56416
implementInitializationMemberChannelComReqDto.setMessageTemplateCode("THIRD_QA_SESSION_MESSAGE_TEMPLATE");//CUSTOM_CONVENTION//sourceId:1403714_1_56416
implementInitializationMemberChannelComReqDto.setChannelName("我的智能问答");//CUSTOM_CONVENTION//sourceId:1403722_1_56416
implementInitializationMemberChannelComReqDto.setBorcScene("TOB_SCENE");//sourceId:1403725_1_56416
implementInitializationMemberChannelComReqDto.setIsAssistant("FALSE");//sourceId:1403864_1_56416
implementInitializationMemberChannelComReqDto.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1403740_1_56416
if(reqDto!=null){
      implementInitializationMemberChannelComReqDto.setChannelTypeCode(reqDto.getChannelTypeCode());//SimpleFieldAssign//sourceId:1403739_1_56416
implementInitializationMemberChannelComReqDto.setNewMessage(reqDto.getContent());//SimpleFieldAssign//sourceId:1403724_1_56416
implementInitializationMemberChannelComReqDto.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1403726_1_56416
implementInitializationMemberChannelComReqDto.setUserId(reqDto.getUserId());//SimpleFieldAssign//sourceId:1403727_1_56416
    }
if(queryChannelDetailComRespDto!=null){
      implementInitializationMemberChannelComReqDto.setMsgChannelClassCode(queryChannelDetailComRespDto.getMsgChannelClassCode());//SimpleFieldAssign//sourceId:1477056_1_56416
implementInitializationMemberChannelComReqDto.setChannelLogo(queryChannelDetailComRespDto.getChannelLogo());//SimpleFieldAssign//sourceId:1403723_1_56416
implementInitializationMemberChannelComReqDto.setNewTableTypeCode(queryChannelDetailComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1403730_1_56416
implementInitializationMemberChannelComReqDto.setNewEntityId(queryChannelDetailComRespDto.getEntityId());//SimpleFieldAssign//sourceId:1403731_1_56416
implementInitializationMemberChannelComReqDto.setChannelSpaceId(queryChannelDetailComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1403735_1_56416
implementInitializationMemberChannelComReqDto.setChannelAppId(queryChannelDetailComRespDto.getAppId());//SimpleFieldAssign//sourceId:1403736_1_56416
implementInitializationMemberChannelComReqDto.setSpaceId(queryChannelDetailComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1403728_1_56416
    }
if(queryMemberProfileDetailComRespDto!=null){
      implementInitializationMemberChannelComReqDto.setCounterpartEntityId(queryMemberProfileDetailComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1403732_1_56416
implementInitializationMemberChannelComReqDto.setCounterpartChannelLogo(queryMemberProfileDetailComRespDto.getUserFace());//SimpleFieldAssign//sourceId:1403733_1_56416
implementInitializationMemberChannelComReqDto.setCounterpartChannelName(queryMemberProfileDetailComRespDto.getIdCardName());//SimpleFieldAssign//sourceId:1403734_1_56416
implementInitializationMemberChannelComReqDto.setAppId(queryMemberProfileDetailComRespDto.getAppId());//SimpleFieldAssign//sourceId:1403729_1_56416
    }
if(queryMeMessageVirtualImageDetailComRespDto!=null){
      implementInitializationMemberChannelComReqDto.setVirtualImageCode(queryMeMessageVirtualImageDetailComRespDto.getVirtualImageCode());//SimpleFieldAssign//sourceId:1403737_1_56416
    }

    /*D2执行初始化成员通道(公共)[6804]   */
    Assert.isNull(implementInitializationMemberChannelComReqDto.getUseChannelMethod(),"D3执行想问答(公共)-D2执行初始化成员通道(公共)-使用通道方式不能为空",false);
Assert.isNull(implementInitializationMemberChannelComReqDto.getMessageTemplateCode(),"D3执行想问答(公共)-D2执行初始化成员通道(公共)-消息模板标识不能为空",false);
Assert.isNull(implementInitializationMemberChannelComReqDto.getChannelTypeCode(),"D3执行想问答(公共)-D2执行初始化成员通道(公共)-通道类型编码不能为空",false);
Assert.isNull(implementInitializationMemberChannelComReqDto.getMsgChannelClassCode(),"D3执行想问答(公共)-D2执行初始化成员通道(公共)-消息使用通道类别不能为空",false);
Assert.isNull(implementInitializationMemberChannelComReqDto.getChannelName(),"D3执行想问答(公共)-D2执行初始化成员通道(公共)-通道名称不能为空",false);
Assert.isNull(implementInitializationMemberChannelComReqDto.getChannelLogo(),"D3执行想问答(公共)-D2执行初始化成员通道(公共)-通道缩略图地址不能为空",false);
Assert.isNull(implementInitializationMemberChannelComReqDto.getNewTableTypeCode(),"D3执行想问答(公共)-D2执行初始化成员通道(公共)-通道归属主体内容类型编码不能为空",false);
Assert.isNull(implementInitializationMemberChannelComReqDto.getNewEntityId(),"D3执行想问答(公共)-D2执行初始化成员通道(公共)-通道归属主体内容ID不能为空",false);
Assert.isNull(implementInitializationMemberChannelComReqDto.getChannelSpaceId(),"D3执行想问答(公共)-D2执行初始化成员通道(公共)-通道归属空间ID不能为空",false);
Assert.isNull(implementInitializationMemberChannelComReqDto.getChannelAppId(),"D3执行想问答(公共)-D2执行初始化成员通道(公共)-通道归属联盟应用ID不能为空",false);
Assert.isNull(implementInitializationMemberChannelComReqDto.getNewMessage(),"D3执行想问答(公共)-D2执行初始化成员通道(公共)-最新消息文本不能为空",false);
Assert.isNull(implementInitializationMemberChannelComReqDto.getUserId(),"D3执行想问答(公共)-D2执行初始化成员通道(公共)-归属个人账号ID不能为空",false);
Assert.isNull(implementInitializationMemberChannelComReqDto.getBorcScene(),"D3执行想问答(公共)-D2执行初始化成员通道(公共)-toB或toC场景不能为空",false);
Assert.isNull(implementInitializationMemberChannelComReqDto.getCounterpartEntityId(),"D3执行想问答(公共)-D2执行初始化成员通道(公共)-发送方是员工或个人ID不能为空",false);
Assert.isNull(implementInitializationMemberChannelComReqDto.getCounterpartChannelLogo(),"D3执行想问答(公共)-D2执行初始化成员通道(公共)-发送方缩略图地址不能为空",false);
Assert.isNull(implementInitializationMemberChannelComReqDto.getCounterpartChannelName(),"D3执行想问答(公共)-D2执行初始化成员通道(公共)-发送方名称不能为空",false);
Assert.isNull(implementInitializationMemberChannelComReqDto.getIsAssistant(),"D3执行想问答(公共)-D2执行初始化成员通道(公共)-发送方是否助手不能为空",false);
Assert.isNull(implementInitializationMemberChannelComReqDto.getOperateTime(),"D3执行想问答(公共)-D2执行初始化成员通道(公共)-操作时间不能为空",false);
Assert.isNull(implementInitializationMemberChannelComReqDto.getSpaceId(),"D3执行想问答(公共)-D2执行初始化成员通道(公共)-创建于空间ID不能为空",false);
Assert.isNull(implementInitializationMemberChannelComReqDto.getAppId(),"D3执行想问答(公共)-D2执行初始化成员通道(公共)-创建于联盟应用ID不能为空",false);
      implementInitializationMemberChannelComRespDto = fwCompMessageClient.implementInitializationMemberChannelCom(implementInitializationMemberChannelComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
ImplementNewInitializationMessageNumComRespDto implementNewInitializationMessageNumComRespDto = null;
    if(implementInitializationMemberChannelComRespDto !=null){
          ImplementNewInitializationMessageNumComReqDto implementNewInitializationMessageNumComReqDto=new ImplementNewInitializationMessageNumComReqDto();
  implementNewInitializationMessageNumComReqDto.setSurfaceCode("MEMBER_CHANNEL_RELATION");//sourceId:1492428_1_59871
if(implementInitializationMemberChannelComRespDto!=null){
      implementNewInitializationMessageNumComReqDto.setEntityId(implementInitializationMemberChannelComRespDto.getMemberChannelRelationId());//SimpleFieldAssign//sourceId:1492429_1_59871
implementNewInitializationMessageNumComReqDto.setMessageChannelId(implementInitializationMemberChannelComRespDto.getChannelId());//SimpleFieldAssign//sourceId:1492431_1_59871
    }
if(reqDto!=null){
      implementNewInitializationMessageNumComReqDto.setChannelTypeCode(reqDto.getChannelTypeCode());//SimpleFieldAssign//sourceId:1492430_1_59871
implementNewInitializationMessageNumComReqDto.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1492432_1_59871
implementNewInitializationMessageNumComReqDto.setUserId(reqDto.getUserId());//SimpleFieldAssign//sourceId:1492433_1_59871
implementNewInitializationMessageNumComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1492434_1_59871
    }

    /*D2-执行初始化消息数量（新）(公共)[7908]   */
    Assert.isNull(implementNewInitializationMessageNumComReqDto.getSurfaceCode(),"D3执行想问答(公共)-D2-执行初始化消息数量（新）(公共)-归属内容类型编码不能为空",false);
Assert.isNull(implementNewInitializationMessageNumComReqDto.getEntityId(),"D3执行想问答(公共)-D2-执行初始化消息数量（新）(公共)-归属内容ID不能为空",false);
Assert.isNull(implementNewInitializationMessageNumComReqDto.getChannelTypeCode(),"D3执行想问答(公共)-D2-执行初始化消息数量（新）(公共)-通道类型编码不能为空",false);
Assert.isNull(implementNewInitializationMessageNumComReqDto.getMessageChannelId(),"D3执行想问答(公共)-D2-执行初始化消息数量（新）(公共)-消息通道ID不能为空",false);
Assert.isNull(implementNewInitializationMessageNumComReqDto.getOriginalRoleMemberId(),"D3执行想问答(公共)-D2-执行初始化消息数量（新）(公共)-身份人员ID不能为空",false);
Assert.isNull(implementNewInitializationMessageNumComReqDto.getUserId(),"D3执行想问答(公共)-D2-执行初始化消息数量（新）(公共)-账号不能为空",false);
Assert.isNull(implementNewInitializationMessageNumComReqDto.getSpaceId(),"D3执行想问答(公共)-D2-执行初始化消息数量（新）(公共)-创建于空间ID不能为空",false);
      implementNewInitializationMessageNumComRespDto = fwCompMessageClient.implementNewInitializationMessageNumCom(implementNewInitializationMessageNumComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
ImplementGroupSendMessagesNpeopleComRespDto implementGroupSendMessagesNpeopleComRespDto_6 = null;
    if(queryUserInfoDetailComRespDto !=null&&queryChannelDetailComRespDto !=null&&implementInitializationMemberChannelComRespDto !=null){
          ImplementGroupSendMessagesNpeopleComReqDto implementGroupSendMessagesNpeopleComReqDto_4=new ImplementGroupSendMessagesNpeopleComReqDto();
  implementGroupSendMessagesNpeopleComReqDto_4.setBorcScene("TOB_SCENE");//sourceId:1403748_1_56417
implementGroupSendMessagesNpeopleComReqDto_4.setMessageLocationTypeCode("INTELLIGENT_STUDY");//CUSTOM_CONVENTION//sourceId:1403749_1_56417
implementGroupSendMessagesNpeopleComReqDto_4.setMessageTemplateCode("THIRD_QA_SESSION_MESSAGE_TEMPLATE");//CUSTOM_CONVENTION//sourceId:1403757_1_56417
implementGroupSendMessagesNpeopleComReqDto_4.setIsAssistant("FALSE");//sourceId:1403766_1_56417
implementGroupSendMessagesNpeopleComReqDto_4.setMessageRole("user");//sourceId:1403750_1_56417
implementGroupSendMessagesNpeopleComReqDto_4.setMessageImportantLevel(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:1403763_1_56417
implementGroupSendMessagesNpeopleComReqDto_4.setMessageTitle("我的问题");//CUSTOM_CONVENTION//sourceId:1403907_1_56417
implementGroupSendMessagesNpeopleComReqDto_4.setHandleType("NO_NEED_HANDLING");//sourceId:1443708_1_56417
implementGroupSendMessagesNpeopleComReqDto_4.setPlatformReplace("FALSE");//sourceId:1403760_1_56417
implementGroupSendMessagesNpeopleComReqDto_4.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1403771_1_56417
implementGroupSendMessagesNpeopleComReqDto_4.setComNumField(Long.valueOf(2));//CUSTOM_CONVENTION//sourceId:1403765_1_56417
if(reqDto!=null){
      implementGroupSendMessagesNpeopleComReqDto_4.setSenderOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1403906_1_56417
implementGroupSendMessagesNpeopleComReqDto_4.setSenderUserId(reqDto.getUserId());//SimpleFieldAssign//sourceId:1403752_1_56417
implementGroupSendMessagesNpeopleComReqDto_4.setMessageContent(reqDto.getContent());//SimpleFieldAssign//sourceId:1403764_1_56417
implementGroupSendMessagesNpeopleComReqDto_4.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1403761_1_56417
implementGroupSendMessagesNpeopleComReqDto_4.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:1403762_1_56417
    }
if(queryUserInfoDetailComRespDto!=null){
      implementGroupSendMessagesNpeopleComReqDto_4.setSenderProfilePictureAddress(queryUserInfoDetailComRespDto.getUserFace());//SimpleFieldAssign//sourceId:1403753_1_56417
implementGroupSendMessagesNpeopleComReqDto_4.setNameOfSender(queryUserInfoDetailComRespDto.getIdCardName());//SimpleFieldAssign//sourceId:1403754_1_56417
    }
if(queryChannelDetailComRespDto!=null){
      implementGroupSendMessagesNpeopleComReqDto_4.setSurfaceCode(queryChannelDetailComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1403755_1_56417
implementGroupSendMessagesNpeopleComReqDto_4.setEntityId(queryChannelDetailComRespDto.getEntityId());//SimpleFieldAssign//sourceId:1403756_1_56417
implementGroupSendMessagesNpeopleComReqDto_4.setMsgChannelClassCode(queryChannelDetailComRespDto.getMsgChannelClassCode());//SimpleFieldAssign//sourceId:1447844_1_56417
implementGroupSendMessagesNpeopleComReqDto_4.setChannelTypeCode(queryChannelDetailComRespDto.getChannelTypeCode());//SimpleFieldAssign//sourceId:1403770_1_56417
implementGroupSendMessagesNpeopleComReqDto_4.setMessageChannelId(queryChannelDetailComRespDto.getMessageChannelId());//SimpleFieldAssign//sourceId:1403758_1_56417
    }
if(implementInitializationMemberChannelComRespDto!=null){
      implementGroupSendMessagesNpeopleComReqDto_4.setMemberChannelRelationId(implementInitializationMemberChannelComRespDto.getMemberChannelRelationId());//SimpleFieldAssign//sourceId:1443709_1_56417
    }

    /*D2执行群里会话发消息N人(提问)[7028]   */
    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getBorcScene(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-toB或toC场景不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getMessageLocationTypeCode(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息位置标识不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getMessageTemplateCode(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息模板标识不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getIsAssistant(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方是否助手不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getMessageRole(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方角色不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getSenderOriginalRoleMemberId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方身份人员ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getSenderUserId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方账号ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getSenderProfilePictureAddress(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方头像地址不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getNameOfSender(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-发送方姓名不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getSurfaceCode(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-归属内容类型编码不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getEntityId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-归属内容ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getMessageImportantLevel(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息重要紧急度层级不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getMessageTitle(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息标题不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getMessageContent(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息内容不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getMsgChannelClassCode(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息使用通道类别不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getChannelTypeCode(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-通道类型编码不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getMessageChannelId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-消息通道ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getMemberChannelRelationId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-成员通道关系ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getHandleType(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-处理类型不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getPlatformReplace(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-是否平台代操作不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getOperateTime(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-操作时间不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getSpaceId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-创建于空间ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getAppId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-创建于联盟应用ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_4.getComNumField(),"D3执行想问答(公共)-D2执行群里会话发消息N人(提问)-通用数值字段（整数型）不能为空",false);
      implementGroupSendMessagesNpeopleComRespDto_6 = fwCompMessageClient.implementGroupSendMessagesNpeopleCom(implementGroupSendMessagesNpeopleComReqDto_4).getData()/*vcase invoke 跨dubbo调用;*/;
      Assert.isTrue(implementGroupSendMessagesNpeopleComRespDto_6== null||  implementGroupSendMessagesNpeopleComRespDto_6.getMessageId() ==null,"找不到数据，系统异常",false);


           }
QueryPushThirdPartyMessagesListComRespDto queryPushThirdPartyMessagesListComRespDto_3 = null;
    if(queryChannelDetailComRespDto !=null){
          QueryPushThirdPartyMessagesListComReqDto queryPushThirdPartyMessagesListComReqDto_2=new QueryPushThirdPartyMessagesListComReqDto();
  if(queryChannelDetailComRespDto!=null){
      queryPushThirdPartyMessagesListComReqDto_2.setMessageChannelId(queryChannelDetailComRespDto.getMessageChannelId());//SimpleFieldAssign//sourceId:1403938_1_56421
    }
if(reqDto!=null){
      queryPushThirdPartyMessagesListComReqDto_2.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1403941_1_56421
    }

    /*D2查询推第三方问题列表(公共)[8126]   */
    Assert.isNull(queryPushThirdPartyMessagesListComReqDto_2.getMessageChannelId(),"D3执行想问答(公共)-D2查询推第三方问题列表(公共)-消息通道ID不能为空",false);
Assert.isNull(queryPushThirdPartyMessagesListComReqDto_2.getSpaceId(),"D3执行想问答(公共)-D2查询推第三方问题列表(公共)-创建于空间ID不能为空",false);
      queryPushThirdPartyMessagesListComRespDto_3 = fwCompMessageClient.queryPushThirdPartyMessagesListCom(queryPushThirdPartyMessagesListComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;



           }
ImplementGuidedThirdPartyIntelligentQaComRespDto implementGuidedThirdPartyIntelligentQaComRespDto_3 = null;
    if(queryPushThirdPartyMessagesListComRespDto_3 !=null){
          ImplementGuidedThirdPartyIntelligentQaComReqDto implementGuidedThirdPartyIntelligentQaComReqDto_2=new ImplementGuidedThirdPartyIntelligentQaComReqDto();
  implementGuidedThirdPartyIntelligentQaComReqDto_2.setBusModelVersion("PLUS_VERSION");//sourceId:2036958_1_56422
  if(reqDto!=null){
      implementGuidedThirdPartyIntelligentQaComReqDto_2.setResultAspObjId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1403978_1_56422
    }
if(queryPushThirdPartyMessagesListComRespDto_3!= null&&  queryPushThirdPartyMessagesListComRespDto_3.getPushThirdPartyMessagesList() !=null&& !CollectionUtil.isEmpty(queryPushThirdPartyMessagesListComRespDto_3.getPushThirdPartyMessagesList())){
      implementGuidedThirdPartyIntelligentQaComReqDto_2.setGetListIntelligentAnswersList(//objList-to-objLists
        queryPushThirdPartyMessagesListComRespDto_3.getPushThirdPartyMessagesList().stream().map(item -> {
      GetListIntelligentAnswersDto elm = new GetListIntelligentAnswersDto();
      if(item!=null){
      elm.setContent(item.getMessageContent());//SimpleFieldAssign//sourceId:282658_2_56422
elm.setRole(item.getMessageRole());//SimpleFieldAssign//sourceId:282659_2_56422
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1403979_1_56422
    }

    /*D2执行导向第三方智能问答(公共)[8103]   */
    Assert.isNull(implementGuidedThirdPartyIntelligentQaComReqDto_2.getResultAspObjId(),"D3执行想问答(公共)-D2执行导向第三方智能问答(公共)-开通对象ID不能为空",false);
Assert.isNull(implementGuidedThirdPartyIntelligentQaComReqDto_2.getBusModelVersion(),"D3执行想问答(公共)-D2执行导向第三方智能问答(公共)-业务模型版本不能为空",false);
      implementGuidedThirdPartyIntelligentQaComRespDto_3 = fwCompIntelligentCommunicationClient.implementGuidedThirdPartyIntelligentQaCom(implementGuidedThirdPartyIntelligentQaComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;


      implementGuidedThirdPartyIntelligentQaComRespDto_1 = implementGuidedThirdPartyIntelligentQaComRespDto_3;
           }
QueryMemberChannelDetailComRespDto queryMemberChannelDetailComRespDto_4 = null;
    if(queryChannelDetailComRespDto !=null&&queryMemberProfileDetailComRespDto !=null){
          QueryMemberChannelDetailComReqDto queryMemberChannelDetailComReqDto_3=new QueryMemberChannelDetailComReqDto();
  queryMemberChannelDetailComReqDto_3.setBorcScene("TOB_SCENE");//sourceId:1403742_1_59877
if(queryChannelDetailComRespDto!=null){
      queryMemberChannelDetailComReqDto_3.setChannelId(queryChannelDetailComRespDto.getMessageChannelId());//SimpleFieldAssign//sourceId:1403741_1_59877
    }
if(queryMemberProfileDetailComRespDto!=null){
      queryMemberChannelDetailComReqDto_3.setOriginalRoleMemberId(queryMemberProfileDetailComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1403743_1_59877
queryMemberChannelDetailComReqDto_3.setUserId(queryMemberProfileDetailComRespDto.getUserId());//SimpleFieldAssign//sourceId:1403744_1_59877
    }

    /*D2查询成员通道详情(公共)[7305]   */
    Assert.isNull(queryMemberChannelDetailComReqDto_3.getChannelId(),"D3执行想问答(公共)-D2查询成员通道详情(公共)-通道ID不能为空",false);
Assert.isNull(queryMemberChannelDetailComReqDto_3.getBorcScene(),"D3执行想问答(公共)-D2查询成员通道详情(公共)-toB或toC场景不能为空",false);
Assert.isNull(queryMemberChannelDetailComReqDto_3.getOriginalRoleMemberId(),"D3执行想问答(公共)-D2查询成员通道详情(公共)-归属身份人员ID不能为空",false);
Assert.isNull(queryMemberChannelDetailComReqDto_3.getUserId(),"D3执行想问答(公共)-D2查询成员通道详情(公共)-归属个人账号ID不能为空",false);
      queryMemberChannelDetailComRespDto_4 = fwCompMessageClient.queryMemberChannelDetailCom(queryMemberChannelDetailComReqDto_3).getData()/*vcase invoke 跨dubbo调用;*/;



           }
ImplementGroupSendMessagesNpeopleComRespDto implementGroupSendMessagesNpeopleComRespDto_7 = null;
    if(queryMemberProfileDetailComRespDto !=null&&queryChannelDetailComRespDto !=null&&implementGuidedThirdPartyIntelligentQaComRespDto_3 !=null&&queryMemberChannelDetailComRespDto_4 !=null){
          ImplementGroupSendMessagesNpeopleComReqDto implementGroupSendMessagesNpeopleComReqDto_5=new ImplementGroupSendMessagesNpeopleComReqDto();
  implementGroupSendMessagesNpeopleComReqDto_5.setBorcScene("TOB_SCENE");//sourceId:1403943_1_56423
implementGroupSendMessagesNpeopleComReqDto_5.setMessageLocationTypeCode("INTELLIGENT_STUDY");//CUSTOM_CONVENTION//sourceId:1403944_1_56423
implementGroupSendMessagesNpeopleComReqDto_5.setMessageTemplateCode("Q_AND_A_MESSAGE_TEMPLATE");//CUSTOM_CONVENTION//sourceId:1403952_1_56423
implementGroupSendMessagesNpeopleComReqDto_5.setIsAssistant("TRUE");//sourceId:1403961_1_56423
implementGroupSendMessagesNpeopleComReqDto_5.setMessageRole("system");//sourceId:1403945_1_56423
implementGroupSendMessagesNpeopleComReqDto_5.setMessageImportantLevel(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:1403958_1_56423
implementGroupSendMessagesNpeopleComReqDto_5.setMessageTitle("问题回答");//CUSTOM_CONVENTION//sourceId:1403967_1_56423
implementGroupSendMessagesNpeopleComReqDto_5.setHandleType("NO_NEED_HANDLING");//sourceId:1443706_1_56423
implementGroupSendMessagesNpeopleComReqDto_5.setPlatformReplace("FALSE");//sourceId:1403955_1_56423
implementGroupSendMessagesNpeopleComReqDto_5.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1403966_1_56423
implementGroupSendMessagesNpeopleComReqDto_5.setComNumField(Long.valueOf(2));//CUSTOM_CONVENTION//sourceId:1403960_1_56423
if(queryMemberProfileDetailComRespDto!=null){
      implementGroupSendMessagesNpeopleComReqDto_5.setSenderOriginalRoleMemberId(queryMemberProfileDetailComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1403946_1_56423
implementGroupSendMessagesNpeopleComReqDto_5.setSenderUserId(queryMemberProfileDetailComRespDto.getUserId());//SimpleFieldAssign//sourceId:1403947_1_56423
implementGroupSendMessagesNpeopleComReqDto_5.setSenderProfilePictureAddress(queryMemberProfileDetailComRespDto.getUserFace());//SimpleFieldAssign//sourceId:1403948_1_56423
implementGroupSendMessagesNpeopleComReqDto_5.setNameOfSender(queryMemberProfileDetailComRespDto.getIdCardName());//SimpleFieldAssign//sourceId:1403949_1_56423
    }
if(queryChannelDetailComRespDto!=null){
      implementGroupSendMessagesNpeopleComReqDto_5.setSurfaceCode(queryChannelDetailComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1403950_1_56423
implementGroupSendMessagesNpeopleComReqDto_5.setEntityId(queryChannelDetailComRespDto.getEntityId());//SimpleFieldAssign//sourceId:1403951_1_56423
implementGroupSendMessagesNpeopleComReqDto_5.setMsgChannelClassCode(queryChannelDetailComRespDto.getMsgChannelClassCode());//SimpleFieldAssign//sourceId:1447843_1_56423
implementGroupSendMessagesNpeopleComReqDto_5.setChannelTypeCode(queryChannelDetailComRespDto.getChannelTypeCode());//SimpleFieldAssign//sourceId:1403965_1_56423
implementGroupSendMessagesNpeopleComReqDto_5.setMessageChannelId(queryChannelDetailComRespDto.getMessageChannelId());//SimpleFieldAssign//sourceId:1403953_1_56423
    }
if(implementGuidedThirdPartyIntelligentQaComRespDto_3!=null){
      implementGroupSendMessagesNpeopleComReqDto_5.setMessageContent(implementGuidedThirdPartyIntelligentQaComRespDto_3.getContent());//SimpleFieldAssign//sourceId:1403959_1_56423
    }
if(queryMemberChannelDetailComRespDto_4!=null){
      implementGroupSendMessagesNpeopleComReqDto_5.setMemberChannelRelationId(queryMemberChannelDetailComRespDto_4.getMemberChannelRelationId());//SimpleFieldAssign//sourceId:1443707_1_56423
    }
if(reqDto!=null){
      implementGroupSendMessagesNpeopleComReqDto_5.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1403956_1_56423
implementGroupSendMessagesNpeopleComReqDto_5.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:1403957_1_56423
    }

    /*D2执行群里会话发消息N人(第三方回答)[7028]   */
    Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getBorcScene(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-toB或toC场景不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getMessageLocationTypeCode(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息位置标识不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getMessageTemplateCode(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息模板标识不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getIsAssistant(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方是否助手不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getMessageRole(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方角色不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getSenderOriginalRoleMemberId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方身份人员ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getSenderUserId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方账号ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getSenderProfilePictureAddress(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方头像地址不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getNameOfSender(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-发送方姓名不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getSurfaceCode(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-归属内容类型编码不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getEntityId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-归属内容ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getMessageImportantLevel(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息重要紧急度层级不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getMessageTitle(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息标题不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getMessageContent(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息内容不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getHandleType(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-处理类型不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getMsgChannelClassCode(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息使用通道类别不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getChannelTypeCode(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-通道类型编码不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getMessageChannelId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-消息通道ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getMemberChannelRelationId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-成员通道关系ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getPlatformReplace(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-是否平台代操作不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getOperateTime(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-操作时间不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getSpaceId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-创建于空间ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getAppId(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-创建于联盟应用ID不能为空",false);
Assert.isNull(implementGroupSendMessagesNpeopleComReqDto_5.getComNumField(),"D3执行想问答(公共)-D2执行群里会话发消息N人(第三方回答)-通用数值字段（整数型）不能为空",false);
      implementGroupSendMessagesNpeopleComRespDto_7 = fwCompMessageClient.implementGroupSendMessagesNpeopleCom(implementGroupSendMessagesNpeopleComReqDto_5).getData()/*vcase invoke 跨dubbo调用;*/;



           }
    }
    }
      }
ImplementWantAskAnswerComRespDto retData = new ImplementWantAskAnswerComRespDto();
  if(implementGuidedThirdPartyIntelligentQaComRespDto_1!=null){
      retData.setContent(implementGuidedThirdPartyIntelligentQaComRespDto_1.getContent());//SimpleFieldAssign//sourceId:1403982_1
    }




return retData;
  }
/**
   * D3执行记录想法(公共)[8289]
   * gen by moon at 12/13/2024, 11:12:25 PM
   */
  @Trace(operationName = "D3执行记录想法(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementRecordIdeasComRespDto implementRecordIdeasCom(ImplementRecordIdeasComReqDto reqDto){


      ImplementCreateMsgAndNumComRespDto implementCreateMsgAndNumComRespDto_1 =null;
      //步骤0: M3执行第四接收字段（特殊方法） - implementFourthReceivingField
     //ModelCode: receptionService
        ImplementFourthReceivingFieldRespDto receptionServiceRes = null;
    ImplementFourthReceivingFieldReqDto receptionServiceReq=new ImplementFourthReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1479288_1
receptionServiceReq.setUserId(reqDto.getUserId());//SimpleFieldAssign//sourceId:1479290_1
receptionServiceReq.setCreateInductionId(reqDto.getCreateInductionId());//SimpleFieldAssign//sourceId:1479350_1
receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1479293_1
receptionServiceReq.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:1479294_1
receptionServiceReq.setContent(reqDto.getContent());//SimpleFieldAssign//sourceId:1479296_1
receptionServiceReq.setCustomField(reqDto.getCustomField());//SimpleFieldAssign//sourceId:1494120_1
    }

    /*M3执行第四接收字段（特殊方法）[8259]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getOriginalRoleMemberId(),"D3执行记录想法(公共)-M3执行第四接收字段（特殊方法）-身份人员ID不能为空",false);
Assert.isNull(receptionServiceReq.getUserId(),"D3执行记录想法(公共)-M3执行第四接收字段（特殊方法）-账号ID不能为空",false);
Assert.isNull(receptionServiceReq.getCreateInductionId(),"D3执行记录想法(公共)-M3执行第四接收字段（特殊方法）-创建人就职记录ID不能为空",false);
Assert.isNull(receptionServiceReq.getSpaceId(),"D3执行记录想法(公共)-M3执行第四接收字段（特殊方法）-创建于空间ID不能为空",false);
Assert.isNull(receptionServiceReq.getAppId(),"D3执行记录想法(公共)-M3执行第四接收字段（特殊方法）-创建于联盟应用ID不能为空",false);
Assert.isNull(receptionServiceReq.getContent(),"D3执行记录想法(公共)-M3执行第四接收字段（特殊方法）-消息内容不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField(),"D3执行记录想法(公共)-M3执行第四接收字段（特殊方法）-自定义字段不能为空",false);
      receptionServiceRes = nbIntelligentCommunication.implementFourthReceivingField(receptionServiceReq);




//步骤1: D2执行判断想法类型(公共) - implementDetermineTypeIdeaCom
     ImplementDetermineTypeIdeaComRespDto implementDetermineTypeIdeaComRespDto = null;
    ImplementDetermineTypeIdeaComReqDto implementDetermineTypeIdeaComReqDto=new ImplementDetermineTypeIdeaComReqDto();
  if(reqDto!=null){
      implementDetermineTypeIdeaComReqDto.setCustomField(reqDto.getCustomField());//SimpleFieldAssign//sourceId:1495342_1
    }

    /*D2执行判断想法类型(公共)[8324]   */
    Assert.isNull(implementDetermineTypeIdeaComReqDto.getCustomField(),"D3执行记录想法(公共)-D2执行判断想法类型(公共)-自定义字段不能为空",false);
      implementDetermineTypeIdeaComRespDto = fwCompIntelligentCommunicationClient.implementDetermineTypeIdeaCom(implementDetermineTypeIdeaComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




//步骤2: M3执行业务应用公共字段推送内存（特殊方法） - implementBizPublicFieldPushMemory
     //ModelCode: publicFieldCache
        ImplementBizPublicFieldPushMemoryRespDto publicFieldCacheRes = null;
    ImplementBizPublicFieldPushMemoryReqDto publicFieldCacheReq=new ImplementBizPublicFieldPushMemoryReqDto();
  if(reqDto!=null){
      publicFieldCacheReq.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1479348_1
publicFieldCacheReq.setUserId(reqDto.getUserId());//SimpleFieldAssign//sourceId:1479349_1
publicFieldCacheReq.setCreateInductionId(reqDto.getCreateInductionId());//SimpleFieldAssign//sourceId:1479344_1
publicFieldCacheReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1479345_1
publicFieldCacheReq.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:1479346_1
    }

    /*M3执行业务应用公共字段推送内存（特殊方法）[4520]  用于定时任务执行时，获取定时任务执行所需的公共信息，存入缓存，供定时任务中虚拟用况使用 */
    Assert.isNull(publicFieldCacheReq.getOriginalRoleMemberId(),"D3执行记录想法(公共)-M3执行业务应用公共字段推送内存（特殊方法）-身份人员ID不能为空",false);
Assert.isNull(publicFieldCacheReq.getUserId(),"D3执行记录想法(公共)-M3执行业务应用公共字段推送内存（特殊方法）-账号ID不能为空",false);
      publicFieldCacheRes = nbIntelligentCommunication.implementBizPublicFieldPushMemory(publicFieldCacheReq);




//步骤3: D2执行时间格式化(公共) - implementDateFormatCom
     ImplementDateFormatComRespDto implementDateFormatComRespDto = null;
    ImplementDateFormatComReqDto implementDateFormatComReqDto=new ImplementDateFormatComReqDto();
  implementDateFormatComReqDto.setComTimeField(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1479309_1
implementDateFormatComReqDto.setTimeFormatMode("yyyy-MM-dd");//CUSTOM_CONVENTION//sourceId:1479310_1

    /*D2执行时间格式化(公共)[8203]   */
    Assert.isNull(implementDateFormatComReqDto.getComTimeField(),"D3执行记录想法(公共)-D2执行时间格式化(公共)-通用时间字段不能为空",false);
Assert.isNull(implementDateFormatComReqDto.getTimeFormatMode(),"D3执行记录想法(公共)-D2执行时间格式化(公共)-时间格式模式不能为空",false);
      implementDateFormatComRespDto = fwCompInterfaceModeClient.implementDateFormatCom(implementDateFormatComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




//步骤4: D1-2查询个人资料详情(公共) - queryUserInfoDetailCom
     QueryUserInfoDetailComRespDto queryUserInfoDetailComRespDto = null;
    QueryUserInfoDetailComReqDto queryUserInfoDetailComReqDto=new QueryUserInfoDetailComReqDto();
  if(reqDto!=null){
      queryUserInfoDetailComReqDto.setUserId(reqDto.getUserId());//SimpleFieldAssign//sourceId:1479312_1
    }

    /*D1-2查发送人头像、姓名[408]   */
    Assert.isNull(queryUserInfoDetailComReqDto.getUserId(),"D3执行记录想法(公共)-D1-2查发送人头像、姓名-账号不能为空",false);
      queryUserInfoDetailComRespDto = fwBaseUserClient.queryUserInfoDetailCom(queryUserInfoDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




//步骤5: D3执行生成消息及数量(公共) - implementCreateMsgAndNumCom
     ImplementCreateMsgAndNumComRespDto implementCreateMsgAndNumComRespDto = null;
    if(implementDetermineTypeIdeaComRespDto !=null){
          ImplementCreateMsgAndNumComReqDto implementCreateMsgAndNumComReqDto=new ImplementCreateMsgAndNumComReqDto();
  implementCreateMsgAndNumComReqDto.setMsgAndLocUsageScene("WORK_TASK_SCENE");//sourceId:1479091_1
implementCreateMsgAndNumComReqDto.setSendMsgTechnologyMode("LABOUR_SEND_NULL");//sourceId:1479094_1
implementCreateMsgAndNumComReqDto.setMessageReceiverType("BY_APPOINT_MEM");//sourceId:1479093_1
implementCreateMsgAndNumComReqDto.setNewTableTypeCode("OMS_FRAMEWORK_ORIGINAL_ROLE_MEMBER");//sourceId:1479095_1
implementCreateMsgAndNumComReqDto.setMsgTableTypeCode("OMS_FRAMEWORK_ORIGINAL_ROLE_MEMBER");//sourceId:1479109_1
implementCreateMsgAndNumComReqDto.setPlatformReplace("FALSE");//sourceId:1479126_1
implementCreateMsgAndNumComReqDto.setHandleType("NO_NEED_HANDLING");//sourceId:1479123_1
implementCreateMsgAndNumComReqDto.setMessageLocationCode("RECORD_IDEAS");//CUSTOM_CONVENTION//sourceId:1479121_1
implementCreateMsgAndNumComReqDto.setMessageImportantLevel(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:1479127_1
implementCreateMsgAndNumComReqDto.setMsgChannelClassCode("IDEA");//sourceId:1479119_1
implementCreateMsgAndNumComReqDto.setMessageChannelTypeCode("PERSONAL_IDEA_SESSION");//sourceId:1479120_1
implementCreateMsgAndNumComReqDto.setFirstFieldName("content");//CUSTOM_CONVENTION//sourceId:1479100_1
implementCreateMsgAndNumComReqDto.setSecondFieldName("idCardName");//CUSTOM_CONVENTION//sourceId:1479102_1
implementCreateMsgAndNumComReqDto.setThirdFieldName("todayDate");//CUSTOM_CONVENTION//sourceId:1479104_1
if(implementDetermineTypeIdeaComRespDto!=null){
      implementCreateMsgAndNumComReqDto.setSendMsgScene(implementDetermineTypeIdeaComRespDto.getSendMsgScene());//SimpleFieldAssign//sourceId:1479092_1
implementCreateMsgAndNumComReqDto.setMessageTemplateCode(implementDetermineTypeIdeaComRespDto.getMessageTemplateCode());//SimpleFieldAssign//sourceId:1479122_1
implementCreateMsgAndNumComReqDto.setMsgTitleTemplateSemanticEngineCode(implementDetermineTypeIdeaComRespDto.getMsgTitleTemplateSemanticEngineCode());//SimpleFieldAssign//sourceId:1479106_1
implementCreateMsgAndNumComReqDto.setTitleFieldName(implementDetermineTypeIdeaComRespDto.getTitleFieldName());//SimpleFieldAssign//sourceId:1479107_1
implementCreateMsgAndNumComReqDto.setTitleFieldValue(implementDetermineTypeIdeaComRespDto.getTitleFieldValue());//SimpleFieldAssign//sourceId:1479108_1
    }
if(reqDto!=null){
      implementCreateMsgAndNumComReqDto.setNewEntityId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1479096_1
implementCreateMsgAndNumComReqDto.setMsgEntiyId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1479110_1
implementCreateMsgAndNumComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1479099_1
implementCreateMsgAndNumComReqDto.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:1479111_1
implementCreateMsgAndNumComReqDto.setFirstFieldValue(reqDto.getContent());//SimpleFieldAssign//sourceId:1479101_1
    }
if(queryUserInfoDetailComRespDto!=null){
      implementCreateMsgAndNumComReqDto.setSecondFieldValue(queryUserInfoDetailComRespDto.getIdCardName());//SimpleFieldAssign//sourceId:1479103_1
    }
if(implementDateFormatComRespDto!=null){
      implementCreateMsgAndNumComReqDto.setThirdFieldValue(implementDateFormatComRespDto.getComTxtField());//SimpleFieldAssign//sourceId:1479105_1
    }

    /*D3执行生成消息及数量(公共)[8243]   */
    Assert.isNull(implementCreateMsgAndNumComReqDto.getMsgAndLocUsageScene(),"D3执行记录想法(公共)-D3执行生成消息及数量(公共)-消息及位置使用场景不能为空",false);
Assert.isNull(implementCreateMsgAndNumComReqDto.getSendMsgScene(),"D3执行记录想法(公共)-D3执行生成消息及数量(公共)-发送消息场景不能为空",false);
Assert.isNull(implementCreateMsgAndNumComReqDto.getSendMsgTechnologyMode(),"D3执行记录想法(公共)-D3执行生成消息及数量(公共)-发送消息技术模型不能为空",false);
Assert.isNull(implementCreateMsgAndNumComReqDto.getMessageReceiverType(),"D3执行记录想法(公共)-D3执行生成消息及数量(公共)-消息接收方类型不能为空",false);
Assert.isNull(implementCreateMsgAndNumComReqDto.getNewTableTypeCode(),"D3执行记录想法(公共)-D3执行生成消息及数量(公共)-通道归属主体内容类型编码不能为空",false);
Assert.isNull(implementCreateMsgAndNumComReqDto.getNewEntityId(),"D3执行记录想法(公共)-D3执行生成消息及数量(公共)-通道归属主体内容ID不能为空",false);
Assert.isNull(implementCreateMsgAndNumComReqDto.getMsgTableTypeCode(),"D3执行记录想法(公共)-D3执行生成消息及数量(公共)-消息内容表类型编码不能为空",false);
Assert.isNull(implementCreateMsgAndNumComReqDto.getMsgEntiyId(),"D3执行记录想法(公共)-D3执行生成消息及数量(公共)-消息内容表主键ID不能为空",false);
Assert.isNull(implementCreateMsgAndNumComReqDto.getSpaceId(),"D3执行记录想法(公共)-D3执行生成消息及数量(公共)-创建于空间ID不能为空",false);
Assert.isNull(implementCreateMsgAndNumComReqDto.getAppId(),"D3执行记录想法(公共)-D3执行生成消息及数量(公共)-创建于联盟应用ID不能为空",false);
Assert.isNull(implementCreateMsgAndNumComReqDto.getPlatformReplace(),"D3执行记录想法(公共)-D3执行生成消息及数量(公共)-是否平台代操作不能为空",false);
Assert.isNull(implementCreateMsgAndNumComReqDto.getHandleType(),"D3执行记录想法(公共)-D3执行生成消息及数量(公共)-处理类型不能为空",false);
Assert.isNull(implementCreateMsgAndNumComReqDto.getMessageLocationCode(),"D3执行记录想法(公共)-D3执行生成消息及数量(公共)-消息位置标识不能为空",false);
Assert.isNull(implementCreateMsgAndNumComReqDto.getMessageImportantLevel(),"D3执行记录想法(公共)-D3执行生成消息及数量(公共)-消息重要紧急度层级不能为空",false);
Assert.isNull(implementCreateMsgAndNumComReqDto.getMsgChannelClassCode(),"D3执行记录想法(公共)-D3执行生成消息及数量(公共)-消息使用通道类别不能为空",false);
Assert.isNull(implementCreateMsgAndNumComReqDto.getMessageChannelTypeCode(),"D3执行记录想法(公共)-D3执行生成消息及数量(公共)-通道类型编码不能为空",false);
Assert.isNull(implementCreateMsgAndNumComReqDto.getMessageTemplateCode(),"D3执行记录想法(公共)-D3执行生成消息及数量(公共)-消息模板标识不能为空",false);
Assert.isNull(implementCreateMsgAndNumComReqDto.getMsgTitleTemplateSemanticEngineCode(),"D3执行记录想法(公共)-D3执行生成消息及数量(公共)-消息标题模板引擎标识不能为空",false);
Assert.isNull(implementCreateMsgAndNumComReqDto.getTitleFieldName(),"D3执行记录想法(公共)-D3执行生成消息及数量(公共)-标题字段字段名不能为空",false);
Assert.isNull(implementCreateMsgAndNumComReqDto.getTitleFieldValue(),"D3执行记录想法(公共)-D3执行生成消息及数量(公共)-标题字段字段值不能为空",false);
Assert.isNull(implementCreateMsgAndNumComReqDto.getFirstFieldName(),"D3执行记录想法(公共)-D3执行生成消息及数量(公共)-第一个字段字段名不能为空",false);
Assert.isNull(implementCreateMsgAndNumComReqDto.getFirstFieldValue(),"D3执行记录想法(公共)-D3执行生成消息及数量(公共)-第一个字段字段值不能为空",false);
Assert.isNull(implementCreateMsgAndNumComReqDto.getSecondFieldName(),"D3执行记录想法(公共)-D3执行生成消息及数量(公共)-第二个字段字段名不能为空",false);
Assert.isNull(implementCreateMsgAndNumComReqDto.getSecondFieldValue(),"D3执行记录想法(公共)-D3执行生成消息及数量(公共)-第二个字段字段值不能为空",false);
Assert.isNull(implementCreateMsgAndNumComReqDto.getThirdFieldName(),"D3执行记录想法(公共)-D3执行生成消息及数量(公共)-第三个字段字段名不能为空",false);
Assert.isNull(implementCreateMsgAndNumComReqDto.getThirdFieldValue(),"D3执行记录想法(公共)-D3执行生成消息及数量(公共)-第三个字段字段值不能为空",false);
      implementCreateMsgAndNumComRespDto = messageService.implementCreateMsgAndNumCom(implementCreateMsgAndNumComReqDto)/*vcase invoke isSameApp*/;


      implementCreateMsgAndNumComRespDto_1 = implementCreateMsgAndNumComRespDto;
           }

ImplementRecordIdeasComRespDto retData = new ImplementRecordIdeasComRespDto();
  if(implementCreateMsgAndNumComRespDto_1!=null){
      retData.setMessageId(implementCreateMsgAndNumComRespDto_1.getMessageId());//SimpleFieldAssign//sourceId:1508203_1
retData.setMessageChannelId(implementCreateMsgAndNumComRespDto_1.getMessageChannelId());//SimpleFieldAssign//sourceId:1508204_1
retData.setMemberChannelRelationId(implementCreateMsgAndNumComRespDto_1.getMemberChannelRelationId());//SimpleFieldAssign//sourceId:1508205_1
    }




return retData;
  }
  //
}
